lnk/microser
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

自主协议库编译通过

Browse Source
This commit is contained in:
lnk
2026-06-15 15:48:16 +08:00
parent d3579a2aa7
commit 7205cb5cb9
621 changed files with 224958 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files

434
mmslib/slog/slogmem.c Normal file
View File

@@ -0,0 +1,434 @@
/************************************************************************/
/* SISCO SOFTWARE MODULE HEADER *****************************************/
/************************************************************************/
/* (c) Copyright Systems Integration Specialists Company, Inc., */
/* 1993-2007, All Rights Reserved */
/* */
/* MODULE NAME : slogmem.c */
/* PRODUCT(S) : SLOG */
/* */
/* MODULE DESCRIPTION : */
/* */
/* GLOBAL FUNCTIONS DEFINED IN THIS MODULE : */
/* */
/* MODIFICATION LOG : */
/* Date Who Rev Comments */
/* -------- --- ------ ------------------------------------------- */
/* 01/15/07 EJV 16 Chg S_LOCK_RESOURCES to S_LOCK_UTIL_RESOURCES*/
/* 07/13/05 JRB 15 slogGetMemMsg: skip timestamp on continuation*/
/* logs & indent 4 chars; indent hex logs. */
/* getMsgBuffer: make size based on max msg. */
/* 02/25/05 MDE 14 Added \n */
/* 01/10/05 MDE 13 Cleanup dump a bit */
/* 07/09/04 EJV 12 All systems: one time/date format in slog hdr*/
/* 03/12/04 GLB 11 Removed "thisFileName" */
/* 02/17/03 JRB 10 Del system includes (using sysincs.h). */
/* 05/24/01 JRB 09 Chg chk_calloc to calloc. This always compiled*/
/* with !DEBUG_SISCO, screws up link. */
/* 10/13/00 EJV 08 Moved glbsem.h below sysincs.h. */
/* 09/13/99 MDE 07 Added SD_CONST modifiers */
/* 02/09/99 DSF 06 Thread-safe slogMem () */
/* Remove extraneous newline in slogMemDump() */
/* 10/23/98 MDE 05 No blank line bet. logs if LOG_NO_HEADER_CR */
/* 10/16/98 DSF 04 Spelling */
/* 10/08/98 MDE 03 Migrated to updated SLOG interface */
/* 06/15/98 MDE 02 Changes to allow compile under C++ */
/* 09/18/97 DSF 01 In slogMemInit (), clear chk_debug_en before */
/* calling chk_calloc () and restore it after. */
/* 04/02/97 DTL 7.00 MMSEASE 7.0 release. See MODL70.DOC for */
/* history. */
/************************************************************************/
#include "glbtypes.h"
#include "sysincs.h"
#include "glbsem.h"
#include "mem_chk.h"
#include "slog.h"
#include "qmem.h"
/************************************************************************/
/* Some mysterious looking function pointers */
/************************************************************************/
ST_VOID *(*slogAllocBuf) (ST_INT size) = qMemAlloc;
ST_VOID (*slogFreeBuf) (ST_VOID *buf) = qMemFree;
/************************************************************************/
/* slogMem */
/************************************************************************/
ST_VOID slogMem (LOG_CTRL *lc,
SD_CONST ST_INT logType,
SD_CONST ST_CHAR *SD_CONST logTypeStr,
SD_CONST ST_CHAR *SD_CONST sourceFile,
SD_CONST ST_INT lineNum,
ST_INT bufLen, SD_CONST ST_CHAR *buf)
{
LOGMEM_ITEM *thisItem;
MEM_LOG_CTRL *mc;
S_GS_INIT ();
S_LOCK_UTIL_RESOURCES ();
/* get pointer to memory control structure */
mc = &lc->mc;
/* Check for initialization */
if (!(mc->state & MEM_STATE_INIT))
{
slogMemInit (lc);
}
/* Get pointer to the destination item and reset the 'next put' index */
thisItem = &mc->item[mc->nextPut];
mc->nextPut++;
if (mc->nextPut >= mc->maxItems) /* check for wraparound */
{
mc->nextPut = 0;
/* Check for autodump && clean */
if (mc->ctrl & MEM_CTRL_AUTODUMP_EN)
{
slogDumpMem (lc); /* Dump memory to log file */
slogResetMem (lc); /* Delete all contents */
}
}
/* Check to see if we need to free the string buffer */
if (thisItem->flags & LMF_USED)
{
(*slogFreeBuf) (thisItem->string);
}
/* Set flags for this item */
if (mc->ctrl & MEM_CTRL_MSG_HDR_EN)
{
thisItem->flags = LMF_HEADER | LMF_USED;
thisItem->sourceFile = sourceFile; /* save source information */
thisItem->lineNum = lineNum;
}
else
thisItem->flags = LMF_USED;
/* If this is a HEX log, remember that it is */
if (mc->ctrl & MEM_CTRL_HEX_LOG)
{
thisItem->flags |= LMF_HEX;
}
/* Save the log type information */
thisItem->logType = logType;
thisItem->logTypeStr = logTypeStr;
/* If time stamping is enabled, need to save the time */
if (lc->logCtrl & LOG_TIME_EN)
strcpy (thisItem->slogTimeText, slogTimeText);
/* Limit the string size (bufLen includes the null) */
if (bufLen > SLOG_MEM_BUF_SIZE)
{
bufLen = SLOG_MEM_BUF_SIZE;
thisItem->string = (ST_CHAR *) (*slogAllocBuf) (bufLen+1);
strncpy (thisItem->string, buf, SLOG_MEM_BUF_SIZE -1);
thisItem->string[SLOG_MEM_BUF_SIZE-1] = 0;
}
else /* no buffer size adjustments req'd */
{
thisItem->string = (ST_CHAR *) (*slogAllocBuf) (bufLen+1);
strcpy (thisItem->string, buf);
}
S_UNLOCK_UTIL_RESOURCES ();
}
/************************************************************************/
/* slogDumpMem */
/************************************************************************/
ST_VOID slogDumpMem (LOG_CTRL *lc)
{
LOGMEM_ITEM *item;
LOGMEM_ITEM *tooFar;
ST_INT count;
FILE *fh;
time_t t;
ST_CHAR fname[SLOG_MAX_FNAME + 1];
MEM_LOG_CTRL *mc;
ST_INT i;
S_GS_INIT ();
S_LOCK_UTIL_RESOURCES ();
/* get pointer to memory control structure */
mc = &lc->mc;
if (!(mc->state & MEM_STATE_INIT))
{
S_UNLOCK_UTIL_RESOURCES ();
return;
}
fh = fopen(mc->dumpFileName, "a+");
if (!fh)
fh = fopen(mc->dumpFileName, "w+");
if (fh)
{
/* Print the dump header */
t = time(NULL);
fprintf (fh,"\n\n***********************************************************");
fprintf (fh,"\n MEMORY LOG LIST %s", ctime(&t));
fprintf (fh,"***********************************************************");
count = mc->maxItems; /* just in case, for loop escape */
/* start at the last logged item, which would be 'next put' */
/* if the list has wrapped, otherwise somewhere down the list */
item = &mc->item[mc->nextPut]; /* Item to log */
tooFar = &mc->item[mc->maxItems]; /* 1 past end of array */
for (i = 0; i < count; ++i,++item) /* for each possible item */
{
if (item >= tooFar) /* check for wrap */
item = mc->item; /* go to top */
if (item->flags & LMF_USED) /* if used .. */
{
if (item->flags & LMF_HEADER)
{ /* header info is to be used */
if (!(lc->logCtrl & LOG_NO_HEADER_CR))
fprintf (fh,"\n");
if (item->logType != SLOG_CONT)
{
if (lc->logCtrl & LOG_TIME_EN) /* user wants time stamp */
fprintf (fh,"\n%s ", item->slogTimeText);
if (!(lc->logCtrl & LOG_LOGTYPE_SUPPRESS))
{
if (item->logTypeStr != NULL)
fprintf (fh,"%s ", item->logTypeStr);
else
fprintf (fh,"LogType:% 2d ", item->logType);
}
if (item->sourceFile && !(lc->logCtrl & LOG_FILENAME_SUPPRESS))
{
slogTrimFileName (fname,item->sourceFile);
fprintf (fh,"(%s %d) ", fname, item->lineNum);
}
if (!(lc->logCtrl & LOG_NO_HEADER_CR))
fprintf (fh,"\n ");
}
}
if (item->logType == SLOG_CONT)
fprintf (fh," ");
fprintf(fh,"%s",item->string);
} /* end if used */
} /* end for each possible item */
fclose(fh);
}
S_UNLOCK_UTIL_RESOURCES ();
}
/************************************************************************/
/* slogResetMem */
/************************************************************************/
ST_VOID slogResetMem (LOG_CTRL *lc)
{
LOGMEM_ITEM *item;
ST_INT i;
MEM_LOG_CTRL *mc;
S_GS_INIT ();
S_LOCK_UTIL_RESOURCES ();
/* get pointer to memory control structure */
mc = &lc->mc;
if (!(mc->state & MEM_STATE_INIT))
return;
/* just go through the list, clear the used flag && free the str buf */
item = mc->item;
for (i = 0; i < mc->maxItems; ++i, ++item)
{
if (item->flags & LMF_USED)
{
item->flags &= ~LMF_USED;
(*slogFreeBuf) (item->string);
}
}
mc->nextPut = 0;
S_UNLOCK_UTIL_RESOURCES ();
}
/************************************************************************/
/* slogMemInit */
/************************************************************************/
#define SLOG_MAX_ITEMS (0xFF00/sizeof(LOGMEM_ITEM))
ST_VOID slogMemInit (LOG_CTRL *lc)
{
MEM_LOG_CTRL *mc;
ST_UINT save_debug_en;
mc = &lc->mc;
if (!mc->maxItems)
{
fprintf (stderr,"\n Memory Logging Problem - 0 Items");
return;
}
if (mc->maxItems > SLOG_MAX_ITEMS)
{
fprintf (stderr,"\n Memory Logging Problem - Too Many Items");
mc->maxItems = SLOG_MAX_ITEMS;
}
if (qMemInit (mc->maxItems))
{
fprintf (stderr,"\n QMEM Initialization Problem");
mc->maxItems = 0;
lc->logCtrl &= ~LOG_MEM_EN;
}
else
{
/* Allocate a zero'd memory block for the item control list */
save_debug_en = chk_debug_en;
chk_debug_en = 0;
mc->item =
(LOGMEM_ITEM *) calloc (mc->maxItems, sizeof (LOGMEM_ITEM));
chk_debug_en = save_debug_en;
}
mc->state |= MEM_STATE_INIT;
}
/************************************************************************/
/* slogGetMemMsg */
/************************************************************************/
/* Need buffer big enough for max msg plus extra space for timestamp. */
/* 50 should leave plenty of safety margin. */
static ST_CHAR getMsgBuffer[SLOG_MEM_BUF_SIZE + 50];
ST_CHAR *slogGetMemMsg (LOG_CTRL *lc, SD_CONST ST_INT msgNum)
{
ST_INT i;
MEM_LOG_CTRL *mc;
ST_INT index;
S_GS_INIT ();
S_LOCK_UTIL_RESOURCES ();
/* get pointer to memory control structure */
mc = &lc->mc;
if (!(mc->state & MEM_STATE_INIT) || msgNum > mc->maxItems)
{
S_UNLOCK_UTIL_RESOURCES ();
return (NULL);
}
/* FInd the start index in the item array */
index = mc->nextPut; /* if wrapped, next put is oldest item */
if (!(mc->item[index].flags & LMF_USED)) /* but if not wrapped */
index = 0; /* oldest is item 0 */
/* Find the 'msgNum' item index (msgNum == 0 means oldest item) */
for (i = 0; i < msgNum; ++i)
{
++index;
if (index >= mc->maxItems) /* check for wraparound */
index = 0;
}
if ((mc->item[index].flags & LMF_USED)) /* if used ... */
{
/* too easy! return (mc->item[index].string); */
if (lc->logCtrl & LOG_TIME_EN)
{
if (mc->item[index].flags & LMF_HEADER)
{
if (mc->item[index].logType == SLOG_CONT)
sprintf (getMsgBuffer," %s", mc->item[index].string); /* indent 4 char*/
else
sprintf (getMsgBuffer,"%s: %s", &mc->item[index].slogTimeText[11],
mc->item[index].string);
}
else if (mc->item[index].flags & LMF_HEX)
sprintf (getMsgBuffer," %s", mc->item[index].string); /* indent 4 char*/
else
sprintf (getMsgBuffer," %s", mc->item[index].string);
}
else
{
if (mc->item[index].logType == SLOG_CONT)
sprintf (getMsgBuffer," %s", mc->item[index].string); /* indent 4 char*/
else
sprintf (getMsgBuffer,"%s", mc->item[index].string);
}
S_UNLOCK_UTIL_RESOURCES ();
return (getMsgBuffer);
}
S_UNLOCK_UTIL_RESOURCES ();
return (NULL);
}
/************************************************************************/
/* slogGetMemCount */
/************************************************************************/
ST_INT slogGetMemCount (LOG_CTRL *lc)
{
MEM_LOG_CTRL *mc;
S_GS_INIT ();
S_LOCK_UTIL_RESOURCES ();
/* get pointer to memory control structure */
mc = &lc->mc;
if (!(mc->state & MEM_STATE_INIT))
{
S_UNLOCK_UTIL_RESOURCES ();
return (0);
}
if (mc->item[mc->nextPut].flags & LMF_USED) /* if wrapped, */
{
S_UNLOCK_UTIL_RESOURCES ();
return (mc->maxItems);
}
else
{
S_UNLOCK_UTIL_RESOURCES ();
return (mc->nextPut);
}
}