cac
/
iec103
6
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

cac

Browse Source
main
unknown 2 years ago
parent e9eef722b1
commit a64e2ca42c
58 changed files with 59251 additions and 0 deletions
Show Stats Download Patch File Download Diff File

31
ClearThread.cpp
Unescape Escape View File

@ -0,0 +1,31 @@
// ClearThread.cpp: implementation of the CClearThread class.
//
//////////////////////////////////////////////////////////////////////
#include "ClearThread.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CClearThread::CClearThread(QTextEdit *pEdit)
{
m_pEditWidget = pEdit;
}
CClearThread::~CClearThread()
{
}
void CClearThread::run()
{
qDebug("clear thread start... ...");
if(m_pEditWidget)
{
m_pEditWidget->clear();
}
qDebug("clear thread finished");
}

24
ClearThread.h
Unescape Escape View File

@ -0,0 +1,24 @@
// ClearThread.h: interface for the CClearThread class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_CLEARTHREAD_H__17C9FD37_21E1_4FC2_83D4_942D1DE68D4B__INCLUDED_)
#define AFX_CLEARTHREAD_H__17C9FD37_21E1_4FC2_83D4_942D1DE68D4B__INCLUDED_
#include <qthread.h>
#include <qtextedit.h>
class CClearThread : public QThread
{
public:
CClearThread(QTextEdit *pEdit);
virtual ~CClearThread();
private:
QTextEdit *m_pEditWidget;
protected:
virtual void run();
};
#endif // !defined(AFX_CLEARTHREAD_H__17C9FD37_21E1_4FC2_83D4_942D1DE68D4B__INCLUDED_)

1502
DSFileSystem.cpp
View File

File diff suppressed because it is too large Load Diff

366
DSFileSystem.h
Unescape Escape View File

@ -0,0 +1,366 @@
/****************************************************************************
* FileName : DSFileSystem.h *
* Programmer : AAAwen *
* Writen at : 2005.05.10 *
* Version : 1.0 *
* Description: define filesystem of flash *
* Last modify: 2005.05.10 *
****************************************************************************/
#ifndef __DSFILESYSTEM_H_ICL__
#define __DSFILESYSTEM_H_ICL__
#include "basetype.h"
#include <stdio.h>
//typedef char* HDSFILE;
/*!
清除数据流已经被读取的字节数
*/
#define SEEK_CLR_RCNT SEEK_END+10
#define SEEK_CUR_EX SEEK_END+11
// 修改DS中的配置文件系统
#define DS_FILESYSTEM_ADDR 0x3b0000
#define DS_FILESYSTEM_LEN (0x50000-4)
#define DS_SECTION_OUT -1 // 段名称长度越限
#define DS_SECTION_NOEXIST 0 // 段名称不存在
#define DS_SECTION_EXIST 1 // 段名称存在
#define DS_SECTION_SEARCH 2 // 段名称查找
typedef struct tsgDSFILE
{
/*!
文件内容长度
*/
long m_lContentLen;
/*!
文件读取的当前位置
*/
long m_lOffset;
/*!
文件读取的字节数量
*/
long m_lReadCount;
// 增加优化配置文件读取项
/*!
段名称是否存在
*/
long m_lSectionOk;
/*!
段名称行数
*/
long m_lSectionLines;
/*!
段名称行数增加标识
*/
long m_lSectionLinesAddFlag;
/*!
段在文件中的偏移位置
*/
long m_lSectionOffset;
/*!
段名称
*/
char m_szSection[64];
/*!
文件正文
*/
char *m_pContent;
}DSFILE, *HDSFILE;
#ifdef OS_WINDOWS
#pragma pack (push,1)
typedef struct tagDSFILESYSTEMHEAD
{
/*!
文件系统中文件数量
*/
int m_iFiles;
/*!
文件系统中首文件偏移
\note
第一个文件=this+m_iOffset
*/
int m_iOffset;
}DSFILESYSTEMHEAD;
typedef struct tagDSFILEHEAD
{
/*!
文件长度(文件内容+文件头)
*/
int m_iFileSize;
/*!
文件内容偏移
*/
int m_iOffset;
/*!
文件名长度
*/
int m_iFileNameLen;
/*!
文件名称
*/
char m_FileName[1];
}DSFILEHEAD, *pDSFILEHEAD;
typedef struct tagFILECONTENT
{
long m_lContentLen;
long m_lOffset;
char m_pContent[1];
}FILECONTENT, *pFILECONTENT;
#pragma pack (pop)
#else
typedef struct tagDSFILESYSTEMHEAD
{
/*!
文件系统中文件数量
*/
int m_iFiles ;
/*!
文件系统中首文件偏移
\note
第一个文件=this+m_iOffset
*/
int m_iOffset ;
}DSFILESYSTEMHEAD;
typedef struct tagDSFILEHEAD
{
/*!
文件长度(文件内容+文件头)
*/
int m_iFileSize ;
/*!
文件内容偏移
*/
int m_iOffset ;
/*!
文件名长度
*/
int m_iFileNameLen ;
/*!
文件名称
*/
char m_FileName[1] ;
}DSFILEHEAD, *pDSFILEHEAD;
typedef struct tagFILECONTENT
{
long m_lContentLen ;
long m_lOffset ;
char m_pContent[1] ;
}FILECONTENT, *pFILECONTENT;
#endif
/*!
\brief 将指定文件载入目的内存
\param szFileName -- 要载入的文件名
\param ppDestMem -- 目的内存指针的指针
\retval -- 返回分配内存长度
\note
如果内存分配失败或者文件为空返回0\n
pDestMem必须在使用后有调用者释放
*/
long LoadFile(const char *szFileName, char **ppDestMem);
/*!
\brief 将指定文件载入目的内存
\param szFileName -- 要载入的文件名
\param ppDestMem -- 目的内存指针的指针
\param pFSAddr -- 文件系统首地址指针
\retval -- 返回分配内存长度
\note
如果内存分配失败或者文件为空返回0\n
pDestMem必须在使用后有调用者释放
*/
long LoadFileInDSFS(const char *szFileName, char **ppDestMem, BYTE *pFSAddr);
/*!
\brief 设置数据流偏移量
\param stream -- 数据流指针
\param offset -- 与origin的偏移值
\param origin -- 初始位置
\retval -- 成功返回0
*/
DSLIB_API int DS_Seek(FILECONTENT *stream, long offset, int origin);
DSLIB_API char *DS_Gets(char *pDest, int iDestMax, FILECONTENT *stream);
/*!
\brief 获取文件长度
\param fp -- 已经打开的文件指针
\retval -- 返回文件长度
*/
DSLIB_API int GetFileLen(FILE *fp);
/*!
\brief 将指定文件载入目的内存
\param szFileName -- 要载入的文件名
\retval -- 返回文件句柄
\note
如果内存分配失败或者文件为空返回0\n
pDestMem必须在使用后有调用者释放
*/
DSLIB_API HDSFILE DSOpenFile(const char *szFileName);
DSLIB_API HDSFILE DSOpenFileEx(const char *szFileName);
/*!
\brief 将指定文件载入目的内存
\param szRootDir -- 文件系统的根路径
\param szFileName -- 要载入的文件名
\retval -- 返回文件句柄
\note
如果内存分配失败或者文件为空返回0\n
pDestMem必须在使用后有调用者释放
该函数仅适合于pc系统，用来浏览文件系统信息
在嵌入式系统中，参数1无意义
*/
DSLIB_API HDSFILE DSOpenFileEx3(const char *szRootDir, const char *szFileName);
DSLIB_API HDSFILE DSOpenFileEx2(const char *szRootDir, const char *szFSName, const char *szFileName);
/*!
\brief 关闭打开的文件
\param hFile -- 打开的文件句柄
\note
如果内存分配失败或者文件为空返回0\n
pDestMem必须在使用后有调用者释放
*/
DSLIB_API BOOL DSCloseFile(HDSFILE hFile);
/*!
\brief 从数据流中获取数据
\param buffer -- 获取数据缓冲区指针
\param size -- 获取数据单元的长度
\param count -- 获取数据单元的数量
\param hFile -- 数据流指针
\retval -- 成功返回实际的读取数据单元数量
*/
DSLIB_API size_t DSfread(void *buffer, size_t size, size_t count, HDSFILE hFile);
/*!
\brief 获取数据流一个字符串(以回车和换行结束)
\param string -- 获取字符串的缓冲区指针
\param origin -- 缓冲区长度
\param hFile -- 数据流指针
\retval -- 成功返回读取的字符串指针
*/
DSLIB_API char *DSfgets(char *string, int iMaxSize, HDSFILE hFile);
/*!
\brief 获取数据流一个字符串(以回车和换行结束)
\param string -- 获取字符串的缓冲区指针
\param origin -- 缓冲区长度
\param hFile -- 数据流指针
\param ioffset -- 当前位置读取偏移
\retval -- 成功返回读取的字符串指针
\note
读取指针不移动,需要用户干预
*/
DSLIB_API char *DSfgetsEx(char *string, int iMaxSize, HDSFILE hFile);
/*!
\brief 读取文件已经读取的数据量
\param hFile -- 数据流指针
\retval -- 实际读取的数据量
*/
DSLIB_API int DSfgetreadcount(HDSFILE hFile);
/*!
\brief 设置数据流偏移量
\param hFile -- 数据流指针
\param offset -- 与origin的偏移值
\param origin -- 初始位置
\retval -- 成功返回0
*/
DSLIB_API int DSfseek(HDSFILE hFile, long offset, int origin);
/*!
\brief 是否到数据流底部
\param hFile -- 数据流指针
\retval -- 成功返回0
*/
DSLIB_API int DSfeof(HDSFILE hFile);
/*!
\brief 是否到数据流底部
\param hFile -- 数据流指针
\retval -- 成功返回0
*/
DSLIB_API int DSfeofEx(HDSFILE hFile);
/*!
\brief 是否数据流全部浏览完毕
\param hFile -- 数据流指针
\retval -- 成功返回0,否则为浏览过的字节数
*/
DSLIB_API int DSfeob(HDSFILE hFile);
/*!
\brief 数据流的偏移量
\param hFile -- 数据流指针
\retval -- 返回偏移量
*/
DSLIB_API int DSftell(HDSFILE hFile);
DSLIB_API int DSHaveSection(char *pSection, HDSFILE hFile);
DSLIB_API int DSSaveSectionOffset(HDSFILE hFile);
DSLIB_API int DSRestoreSectionOffset(HDSFILE hFile);
DSLIB_API int DSAddSectionLines(int iLines, HDSFILE hFile);
DSLIB_API int DSSubSectionLines(int iLines, HDSFILE hFile);
DSLIB_API int DSSetSectionLinesAddFlag(int iFlag, HDSFILE hFile);
DSLIB_API int DSSectionisOver(int iReadLines, HDSFILE hFile);
/*!
\brief 合并所有文件
\param szListFileName -- 要合并的文件列表文件名称
\param szDestFileName -- 合并的目的文件
\param szDestDir -- 文件路径
\retval -- 成功返回TRUE
\note
合并后的文件必须是偶字节对齐
*/
DSLIB_API BOOL FsCombinAllFile(const char *szListFileName, const char *szDestFileName, const char *szDestDir);
/*!
\brief 文件分离
\param szCombinFile -- 合并的文件名称
\param szDestDir -- 要分离的文件目录
\retval -- 成功返回TRUE
*/
DSLIB_API BOOL FsSplitAllFile(const char *szCombinFile, const char *szDestDir);
//测试用
/*!
\brief 读取合并的文件(文件系统)
\param szCombinFile -- 合并的文件名称
\retval -- 成功返回TRUE
*/
DSLIB_API BYTE *FsReadCombinFile(const char *szCombinFile);
DSLIB_API BYTE *FsReadCombinFileEx(const char *szCombinFile);
/*!
\brief 装载文件系统
\param szFileSystem -- 文件系统名称
\param ppDestBuf -- 文件系统的目的缓冲区
\retval -- 成功返回TRUE
*/
DSLIB_API BOOL FsLoadFileSystem(const char *szFileSystem, BYTE **ppDestBuf);
/*!
\brief 卸载文件系统
\param ppDestBuf -- 文件系统的目的缓冲区
\retval -- 成功返回TRUE
*/
DSLIB_API BOOL FsUnLoadFileSystem(BYTE **ppDestBuf);
/*!
\brief 显示指定文件系统路径的文件名称
\param szPath -- 要显示的文件系统路径
\param szFileSystem -- 指定的文件系统
\retval -- 成功返回TRUE
*/
DSLIB_API BOOL FsDirFileName(const char *szPath, const char *szFileSystem);
DSLIB_API void FsDispHead(const char *szName, const char *szFileSystem);
BOOL FsNetToHost(BYTE *pFSBuf);
BOOL FsHostToNet(BYTE *pFSBuf);
void DispMemoryData(const BYTE *pu8Addr, int iLen, int iNumofLine);
#endif

78
DlgDevListImpl.cpp
Unescape Escape View File

@ -0,0 +1,78 @@
// DlgDevListImpl.cpp: implementation of the CDlgDevListImpl class.
//
//////////////////////////////////////////////////////////////////////
#include "DlgDevListImpl.h"
#include <qvariant.h>
#include <qpushbutton.h>
#include <qtable.h>
#include <qlayout.h>
#include <qtooltip.h>
#include <qwhatsthis.h>
#include "qt_public.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
const char* gColumnName[MAX_NET_NUM+1] = {"唗瘍","IP華硊1","IP華硊2","IP華硊3"};
CDlgDevListImpl::CDlgDevListImpl(DEV_DEF *pDevParam, int iDevNum, int iCurSel, QWidget* parent, const char* name, bool modal, WFlags fl)
: DevList(parent, name, modal, fl)
{
int i, j;
char sztmp[128];
m_iCurSelect = 0;
languageChange();
m_CTableDevList->setNumRows(iDevNum);
m_CTableDevList->setNumCols(MAX_NET_NUM+1);
QHeader *pHorHeader = m_CTableDevList->horizontalHeader();
for(i=0; i<(MAX_NET_NUM+1); i++)
{
pHorHeader->setLabel(i, CHS(gColumnName[i]));
}
for(i=0; i<iDevNum; i++)
{
sprintf(sztmp, "%d", i+1);
m_CTableDevList->setText(i, 0, CHS(sztmp));
for(j=0; j<MAX_NET_NUM; j++)
{
sprintf(sztmp, "%d.%d.%d.%d",
((pDevParam[i].IpAddr[j]>>24)&0xFF),
((pDevParam[i].IpAddr[j]>>16)&0xFF),
((pDevParam[i].IpAddr[j]>>8)&0xFF),
(pDevParam[i].IpAddr[j]&0xFF));
m_CTableDevList->setText(i, j+1, CHS(sztmp));
}
}
for(i=0; i<(MAX_NET_NUM+1); i++)
{
m_CTableDevList->adjustColumn( i );
}
m_CTableDevList->selectRow(iCurSel);
}
CDlgDevListImpl::~CDlgDevListImpl()
{
}
void CDlgDevListImpl::languageChange()
{
setCaption(CHS("扢掘蹈桶"));
m_BtnChange->setText(CHS("恁寁"));
m_BtnCancel->setText(CHS("龰秏"));
}
void CDlgDevListImpl::ChangeSelectSlot()
{
m_iCurSelect = m_CTableDevList->currentRow();
}

33
DlgDevListImpl.h
Unescape Escape View File

@ -0,0 +1,33 @@
// DlgDevListImpl.h: interface for the CDlgDevListImpl class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_DLGDEVLISTIMPL_H__DD481030_4A5E_4260_8D3E_A28E986FDDCF__INCLUDED_)
#define AFX_DLGDEVLISTIMPL_H__DD481030_4A5E_4260_8D3E_A28E986FDDCF__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include "devlist.h"
#include "common.h"
class CDlgDevListImpl : public DevList
{
Q_OBJECT
public:
CDlgDevListImpl(DEV_DEF *pDevParam, int iDevNum, int iCurSel, QWidget* parent = 0, const char* name = 0, bool modal = FALSE, WFlags fl = 0);
virtual ~CDlgDevListImpl();
int m_iCurSelect;
int GetCurSelect(){return m_iCurSelect;};
public slots:
virtual void ChangeSelectSlot();
protected slots:
virtual void languageChange();
};
#endif // !defined(AFX_DLGDEVLISTIMPL_H__DD481030_4A5E_4260_8D3E_A28E986FDDCF__INCLUDED_)

11605
Header.h
View File

File diff suppressed because it is too large Load Diff

788
Inifile.cpp
Unescape Escape View File

@ -0,0 +1,788 @@
/*-----------------------------------------------------------------------------------
平台无关的INI文件读写函数 V1.65
张磊 2002.10.3
----------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------
[编写及维护记录]:
(1) V1.0 2002.8.13 仿照windows同类API的调用方式实现了其基本功能。
(2) V1.1 2002.9.13 修正了写配置文件函数中存在的两个BUG
1. 修改配置文件条目时出现部分乱码
2. 写配置文件时，文件尾部原先的超长部分没有被删掉,即没有按新的文件长度截断文件
(3) V1.2 2002.9.18 给QGetPrivateProfileInt()函数增加了16进制字符串识别功能
(4) V1.3 2002.9.19 修正了存在的两个BUG
1. 给StrTrimLeft, StrTrimRight两个函数增加删除TAB字符(ASC码为9)功能,这是由于Ini
文件中进行注释等操作时往往会用到TAB键
2. 从读取的一行文本中剔除";"即注释字符及其后面内容后，新增调用StrTrimAll()函数
删除剩下字符串右边往往存在的空格或TAB字符
(5) V1.4a 2002.9.20 按照一次将文件内容全部读入字符串再处理的算法对三个函数进行了优化
OpenPort()函数执行时间从原来的30秒降为16秒左右
(6) V1.41a 2002.9.23 对读函数继续优化，即连续对相同文件名进行读操作，第一次读文件
时将文件全部读入缓冲区，后面则直接从缓冲区中读取文件内容，不
再需要每次都读入文件全部内容,OpenPort()函数从16秒降到了14秒，
但这种方法和其它文件有些牵连，否则不能正确获知目标文件的变化而
重新装入,导致通用性变差, 最终决定不采用此算法,仍沿用打开-关闭模式
(7) V1.5 2002.9.23 执行速度有了极大提高，具体说明如下：
1. 重写了QGetPrivateProfileString()函数的段搜索部分, 算法为：直接在整个文件字符串
中查找段名,以快速定位段的位置,然后从该位置开始逐行读取,进行键的搜索。由于INI文
件中分段存储的本意就是根据段来快速定位键的位置,因此如果搜索段时也是逐行扫描，
且要找的段可能在INI文件尾部或不存在，将使效率将大大降低；另外对于键的搜索不能
采用这种直接查找字符串的办法，因为即使找到一个键也无法容易地判断它属于哪个段。
使用该算法后，OpenPort()函数执行时间骤降至3-4秒.
2. 由于前置机程序WritePrivateProfileString()函数的调用不超过10次,且都是在交互场合
下，对速度无严格要求，因此该函数中的段搜索及文件读写部分暂时没有优化。
(8) V1.6 2002.9.27 彻底实现了读取ini文件时平台文件格式无关性：
为保证提取一行的操作与平台文件格式无关,只查找换行符(0x0A),这种做法和fgets()类似
对于windows下的ini文件按此方法读出后还要去掉行字符串结尾的一个回车符(0x0D),这样
只查找0x0A,可保证windows下能正确访问unix格式的ini文件。
(9) V1.65 2002.10.3 针对provdata.ini读写时遇到的
1. 行内注释符在该文件中被特别定义成"//"而不是";"
2. 该配置文件中一行尾部有'\'续行符
因此做如下改动:
1. 增加续行功能(续行功能只会出现在键的读取上)
2. 给两个读函数增加两个参数,分别指定行内注释符(缺省为';')和续行符(缺省为'\')
-----------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------
[使用说明]:
(1) 因部分内容和操作系统相关,如换行符号,因此如在unix下运行要确保定义了OS_UNIX宏
(2) 采用全文件字符串搜索算法对INI文件格式有一个约束,既:
要求'['和']'必须和段名紧贴，之间不能留有空格。不允许INI文件中段名形式为"[ xxx ]"，
只有"[xxx]"格式才能正确访问
-------------------------------------------------------------------------------------*/
#include "string.h"
#include "stdio.h"
#include "inifile.h"
#include "common.h"
//#include <qglobal.h>
/*-------------------------------------------------------------------------------------
平台无关的INI文件读函数(字符串),和同类API相比,只是参数类型从const char*变成char*
返回值类型从DWORD改成int,这里返回值的意义从读取字节个数(同名API返回DWORD类型)变成
了读取成功与否标志(int类型),但并不影响使用
-------------------------------------------------------------------------------------*/
int QGetPrivateProfileString(
char* lpszSectionName, //段名
char* lpszKeyName, //键名
char* lpszDefault, //缺省字符串
char* lpszReturnedString, //结果字符串
u_32 nSize, //结果字符串长度
char* lpszFileName, //ini文件名
char* lpszRemarkInLineStr, //行内注释符
char chContinueLineChar //续行符号
)
{
FILE* IniFile = NULL;
BOOL bSecFoundFlag = FALSE;
BOOL bKeyFoundFlag = FALSE;
BOOL bEOF = FALSE;
char szLineBuf[MAX_LINE_BUF_LENGTH]; //行缓冲区
char szKeyItemBuf[MAX_LINE_BUF_LENGTH*4]; //最终内容缓冲区(因键所在行可能因使用续行符而占据多行)
char *lpszFileText = NULL; //放置INI文件全部内容的字符串
char *lpszLineBegin = NULL; //一行开始指针
char *lpszTmp = NULL;
i_32 lFileSize = 0;
int iPos, iRetVal;
BOOL bLineContinue = FALSE; //2002.10.3 续行标志
/*---------------------------------------------------------------------------------
char szLineEndStr[3]; //行末尾换行符号
memset(szLineEndStr, 0, 3);
#ifdef OS_UNIX
strcpy(szLineEndStr, "\n"); //UNIX文本文件行末只有一个换行符'\n'
#else
strcpy(szLineEndStr, "\r\n"); //Windows文本文件行末有一个回车符'\r',一个换行符'\n'
#endif
----------------------------------------------------------------------------------*/
IniFile = fopen(lpszFileName, "rb"); //二进制可读方式打开(文件必须存在)
if(!IniFile)
{
//qDebug("fopen error, %s", lpszFileName);
return FILE_OPEN_ERROR;
}
fseek(IniFile, 0, SEEK_END); //定位到文件尾部
lFileSize = ftell(IniFile); //获取文件尾指针位置(该值=文件总长=文件指针位置最大值+1)
lpszFileText = new char[lFileSize+1];
memset(lpszFileText, 0, lFileSize+1);
fseek(IniFile, 0, SEEK_SET); //重新定位到开头
fread(lpszFileText, 1, lFileSize, IniFile); //将文件所有内容全部读入字符串
fclose(IniFile); //读入全部内容后立即关闭文件
lpszLineBegin = lpszFileText;
//段搜索
/*----------------------------------------------------------------------------
//while(!feof(IniFile))
while(!bEOF)
{
//ReadLineFromFile(IniFile, szLineBuf, MAX_LINE_BUF_LENGTH); //读取一行
memset(szLineBuf, 0, MAX_LINE_BUF_LENGTH);
lpszTmp = strstr(lpszLineBegin, szLineEndStr); //搜索换行符号来定位行末
if(lpszTmp != NULL)
{
strncpy(szLineBuf, lpszLineBegin, min(MAX_LINE_BUF_LENGTH-1, lpszTmp-lpszLineBegin));
lpszLineBegin = lpszTmp + strlen(szLineEndStr);
}
else //最后一行
{
strncpy(szLineBuf, lpszLineBegin, min(MAX_LINE_BUF_LENGTH-1, lpszFileText+lFileSize-lpszLineBegin));
bEOF = TRUE;
}
StrTrimAll(szLineBuf);
if( szLineBuf[0] == ';' || szLineBuf[0] == 0 ) continue; //注释行和空行不处理
//将一行尾部可能存在的";"注释部分剔除(这样key=value的value中不能含有;否则将被当成注释而删除
lpszTmp = strchr(szLineBuf, ';');
if(lpszTmp != NULL) *lpszTmp = 0;
StrTrimAll(szLineBuf); //zl 2002.9.19 ";"和有用内容间必有空格或TAB字符,必须删除这些分割字符
iPos = strlen(szLineBuf) - 1;
if(szLineBuf[0] == '[' && szLineBuf[iPos] == ']') //该行是一个段
{
szLineBuf[iPos] = 0; //去掉"["和"]",便于比较
lpszTmp = &szLineBuf[1];
if( strcmp(lpszTmp, lpszSectionName) == 0 ) //指定的段找到了
{
bSecFoundFlag = TRUE;
break;
}
}
}
----------------------------------------------------------------------------*/
//zl 2002.9.23 新的段搜索算法(直接在包含整个ini文件内容的字符串中定位段名)
char szFindStr[MAX_LINE_BUF_LENGTH]; //搜索字符串
sprintf(szFindStr, "[%s]", lpszSectionName);
while(!bEOF)
{
lpszTmp = strstr(lpszLineBegin, szFindStr);
if( lpszTmp != NULL ) //找到段名,继续验证其是否合法
{
lpszLineBegin = lpszTmp + strlen(szFindStr); //计算新的查找起始位置
if( lpszLineBegin > (lpszFileText + lFileSize -1) ) bEOF = TRUE;
if( lpszTmp == lpszFileText ) //"[xxx]"是文件的开头内容，为合法段名
{
bSecFoundFlag = TRUE;
break;
}
/*----------------------------------------------------------------------------
从'['向前查找,如果遇到换行符0xA,表明是合法段名,如果是空格或tab字符(ASC码9)
则继续向前搜索,如果是此外的其它任何字符,该段名都判为非法, ']'后面的内容不
予处理
----------------------------------------------------------------------------*/
lpszTmp--;
while( lpszTmp >= lpszFileText )
{
if( *lpszTmp == 0xA )
{
bSecFoundFlag = TRUE;
break;
}
else if( *lpszTmp == ' ' || *lpszTmp == 9 )
lpszTmp--;
else
break;
}
if( bSecFoundFlag ) break; //退出外循环
}
else
break; //没找到段名,退出
}
if( !bSecFoundFlag )
{
iRetVal = SECTION_NOT_FOUND;
goto func_end;
}
//继续键搜索(定位段后，对于所属键的查找为逐行读取扫描方式,键可能占用多行)
while(!bEOF)
{
if( !bLineContinue )
memset(szKeyItemBuf, 0, sizeof(szKeyItemBuf)); //关键,控制多行连接
memset(szLineBuf, 0, MAX_LINE_BUF_LENGTH);
//zl 2002.9.27 为保证提取一行的操作与平台文件格式无关,只查找换行符(0x0A),这和fgets()类似
lpszTmp = strchr(lpszLineBegin, 0x0A);
if(lpszTmp != NULL)
{
strncpy(szLineBuf, lpszLineBegin, min(MAX_LINE_BUF_LENGTH-1, lpszTmp-lpszLineBegin)); //从字符串中提取一行
/* 读windows文本文件时,每行尾部多一个回车符(0x0D),必须去掉,否则后面连续出错 */
if( szLineBuf[strlen(szLineBuf)-1] == 0x0D )
szLineBuf[strlen(szLineBuf)-1] = 0;
lpszLineBegin = lpszTmp + 1; //1表示"0x0A"一个字符
}
else //最后一行
{
strncpy(szLineBuf, lpszLineBegin, min(MAX_LINE_BUF_LENGTH-1, lpszFileText+lFileSize-lpszLineBegin));
bEOF = TRUE;
}
StrTrimAll(szLineBuf);
//全注释行和空行不处理
if( szLineBuf[0] == ';' || szLineBuf[0] == 0 )
{
if( bLineContinue && strlen(szKeyItemBuf) > 0 ) //2002.10.7 如果前面是续行,则继续处理szKeyItemBuf已有内容而不是continue重新读入一行,否则当前行(空行或注释行)上面的一个续行的全部内容将丢失
bLineContinue = FALSE;
else
{
bLineContinue = FALSE;
continue;
}
}
else
{
//2002.10.3 判断续行,续行符为行末最后的一个非空格或TAB字符,缺省为'\'
if( szLineBuf[strlen(szLineBuf)-1] == chContinueLineChar )
{
bLineContinue = TRUE;
szLineBuf[strlen(szLineBuf)-1] = 0; //去掉续行符
StrTrimAll(szLineBuf);
strcat(szKeyItemBuf, szLineBuf);
continue;
}
else //无续行字符行
{
bLineContinue = FALSE;
strcat(szKeyItemBuf, szLineBuf);
}
}
//将一行尾部可能存在的行内注释部分(缺省行内注释符是";")剔除
//lpszTmp = strchr(szLineBuf, ';');
lpszTmp = strstr(szKeyItemBuf, lpszRemarkInLineStr); //2002.10.3 可以任意指定行内注释符
if(lpszTmp != NULL) *lpszTmp = 0;
StrTrimAll(szKeyItemBuf); //zl 2002.9.19 ";"和有用内容间必有空格或TAB字符,必须删除这些分割字符
iPos = strlen(szKeyItemBuf)-1;
if(szKeyItemBuf[0] == '[' && szKeyItemBuf[iPos] == ']') //又到了一个段，说明指定段下的指定key没有找到
{
iRetVal = KEY_NOT_FOUND;
goto func_end;
}
lpszTmp = strchr(szKeyItemBuf, '='); //定位'='
if(lpszTmp == NULL) continue; //不含等号的非段行被视为无效行
*lpszTmp = 0; //为便于操作，在'='位置将szLineBuf从中间截断, 将szLineBuf分成key和value两个部分
StrTrimAll(szKeyItemBuf); //此时szLineBuf是key
if(strcmp(szKeyItemBuf, lpszKeyName) == 0) //找到了指定key
{
lpszTmp++;
StrTrimAll(lpszTmp); //lpszTmp++是key对应的value
if( strlen(lpszTmp) < nSize )
strcpy(lpszReturnedString, lpszTmp); //返回key对应的value
else
strncpy(lpszReturnedString, lpszTmp, strlen(lpszTmp));
iRetVal = 1; //1表示正确
bKeyFoundFlag = TRUE;
break;
}
}
if( !bKeyFoundFlag ) iRetVal = KEY_NOT_FOUND;
func_end:
delete [] lpszFileText;
//如果出错同时缺省参数不为NULL，则返回缺省参数
if( iRetVal < 0 && lpszDefault != NULL )
{
if( strlen(lpszDefault) < nSize )
strcpy(lpszReturnedString, lpszDefault);
else
strncpy(lpszReturnedString, lpszDefault, strlen(lpszDefault));
}
return iRetVal;
}
/*-------------------------------------------------------------------------------------
平台无关的INI文件读函数(整数),和同类API相比,只是参数类型从const char*变成char*,
返回值类型从UINT改成int
-------------------------------------------------------------------------------------*/
int QGetPrivateProfileInt(
char* lpszSectionName, //段名
char* lpszKeyName, //键名
int nDefault, //缺省值
char* lpszFileName, //ini文件名
char* lpszRemarkInLineStr, //行内注释符
char chContinueLineChar //续行符号
)
{
int iRet, iResult;
char szNumStr[256]; //数字字符串
iRet = QGetPrivateProfileString(
lpszSectionName, //段名
lpszKeyName, //键名
NULL, //缺省字符串
szNumStr, //结果字符串
256, //结果字符串长度
lpszFileName, //INI文件名
lpszRemarkInLineStr, //行内注释符
chContinueLineChar //续行符号
);
//qDebug(lpszFileName);
if(iRet < 0) return nDefault; //出错则返回缺省值
StrTrimAll(szNumStr);
/*--------------------------------------------------------------------------------
因原先未考虑ini中用"0x1801"这种16进制字符串,导致转换时出错,因为atoi不认识16进制串
2002.9.18 加入非十进制字符串识别支持，目前只支持16进制,字符串格式为"0x数字"
--------------------------------------------------------------------------------*/
BOOL bIsHexFlag = FALSE;
if( strlen(szNumStr) > 2 )
{
if( szNumStr[0] == '0' && szNumStr[1] == 'x' ) bIsHexFlag = TRUE;
}
if( bIsHexFlag )
iRet = sscanf(&szNumStr[2], "%x", &iResult); //16进制
else
iRet = sscanf(szNumStr, "%d", &iResult); //10进制
if( iRet != 1 ) //如数字字符串合法的话,应只转换一个field,故返回值不为1表示出错,此时返回缺省值
return nDefault;
else
return iResult; //正确返回
}
/*-------------------------------------------------------------------------------------
平台无关的INI文件写函数,和同类API相比,只是参数类型从const char*改成了char*
目前该函数尚未对段搜索部分进行优化
-------------------------------------------------------------------------------------*/
BOOL QWritePrivateProfileString(
char* lpszSectionName, //段名
char* lpszKeyName, //键名
char* lpszString, //要写入的字符串
char* lpszFileName //INI文件名
)
{
FILE* IniFile;
char szLineBuf[MAX_LINE_BUF_LENGTH];
char *lpszFrontBlock = NULL, *lpszRearBlock = NULL; //装入前后两块文件各自所占的内存区指针
char *lpszTmp = NULL;
i_32 lPrePos = 0, lCurPos = 0; //前一次读取及本次读取的文件指针位置
bool bSecFoundFlag = FALSE;
bool bKeyFoundFlag = FALSE;
bool bMeetAnotherBlock = FALSE; //遇到另外一个段
i_32 lEndPos;
int iPos;
char szLineEndStr[3]; //行末尾换行符号
#ifdef OS_UNIX
strcpy(szLineEndStr, "\n"); //UNIX文本文件行末只有一个换行符'\n'
#else
strcpy(szLineEndStr, "\r\n"); //Windows文本文件行末有一个回车符'\r',一个换行符'\n'
#endif
IniFile = fopen(lpszFileName, "r+b"); //二进制方式打开，可读可写(但文件必须存在)
if(!IniFile) return false;
fseek(IniFile, 0, SEEK_END); //定位到文件尾部
lEndPos = ftell(IniFile); //计算文件尾部指针位置(该值=文件总长=文件指针位置最大值+1)
fseek(IniFile, 0, SEEK_SET); //重新定位到开头
//先找指定的section
while(!feof(IniFile))
{
lPrePos = lCurPos; //保留上次文件指针位置
ReadLineFromFile(IniFile, szLineBuf, MAX_LINE_BUF_LENGTH); //读取一行
lCurPos = ftell(IniFile); //当前文件指针位置
StrTrimAll(szLineBuf);
if( szLineBuf[0] == ';' || szLineBuf[0] == 0 ) continue; //注释行和空行不处理
//将一行尾部可能存在的";"注释部分剔除(这样key=value的value中不能含有;否则将被当成注释而删除
lpszTmp = strchr(szLineBuf, ';');
if(lpszTmp != NULL) *lpszTmp = 0;
StrTrimAll(szLineBuf); //zl 2002.9.19 ";"和有用内容间必有空格或TAB字符,必须删除这些分割字符
iPos = strlen(szLineBuf) - 1;
if(szLineBuf[0] == '[' && szLineBuf[iPos] == ']') //该行是一个段
{
szLineBuf[iPos] = 0; //去掉"["和"]",便于比较
lpszTmp = &szLineBuf[1];
if( strcmp(lpszTmp, lpszSectionName) == 0 ) //指定的段找到了
{
bSecFoundFlag = TRUE;
break;
}
}
}
//[情况一]：如果未找到指定段,则指定key肯定也不存在,因此即要新建section也要新建key,
// 这些内容就直接追加到文件尾部,同时约定在文件尾部新建一个段时,默认在前面
// 追加换行符号以确保和前面的其它内容不在一行
if( !bSecFoundFlag )
{
char szNewSection[2048];
memset(szNewSection, 0, 2048);
//生成新的段字符串
sprintf(szNewSection, "%s[%s]%s%s = %s%s", szLineEndStr, lpszSectionName, szLineEndStr, lpszKeyName, lpszString, szLineEndStr);
fseek(IniFile, 0, SEEK_END);
fwrite(szNewSection, sizeof(char), strlen(szNewSection), IniFile);
goto func_end;
}
//找到指定段后，再继续找指定key
while(!feof(IniFile))
{
lPrePos = lCurPos; //保留上次文件指针位置
ReadLineFromFile(IniFile, szLineBuf, MAX_LINE_BUF_LENGTH); //读取一行
lCurPos = ftell(IniFile); //保留当前文件指针位置
StrTrimAll(szLineBuf);
if( szLineBuf[0] == ';' || szLineBuf[0] == 0 ) continue; //注释行和空行不处理
//将一行尾部可能存在的";"注释部分剔除(这样key=value的value中不能含有;否则将被当成注释而删除
lpszTmp = strchr(szLineBuf, ';');
if(lpszTmp != NULL) *lpszTmp = 0;
StrTrimAll(szLineBuf); //zl 2002.9.19 ";"和有用内容间必有空格或TAB字符,必须删除这些分割字符
iPos = strlen(szLineBuf)-1;
if(szLineBuf[0] == '[' && szLineBuf[iPos] == ']')
{
bMeetAnotherBlock = TRUE; //又到了一个段，说明指定段下的指定key没有找到
break;
}
lpszTmp = strchr(szLineBuf, '='); //定位'='
if(lpszTmp == NULL) continue; //不含等号的非段行被视为无效行
*lpszTmp = 0; //为便于操作，在'='位置将szLineBuf从中间截断, 将szLineBuf分成key和value两个部分
StrTrimAll(szLineBuf); //此时szLineBuf是key
/* 找到了指定key */
if(strcmp(szLineBuf, lpszKeyName) == 0) //该比较大小写敏感
{
char szKeyValBlock[2048];
memset(szKeyValBlock, 0, 2048);
//重新组织key = value对，实现修改目的
sprintf(szKeyValBlock, "%s = %s%s", szLineBuf, lpszString, szLineEndStr);
//注意：这里和下面的段前插入内容不同，这里是要将原有的key=value对去掉，
//代之以新对,因此lPrePos和lCurPos之间的文件内容(即原有key=value对)不要,
//该操作是替换而不是插入
lpszRearBlock = new char[lEndPos-lCurPos+1];
memset(lpszRearBlock, 0, lEndPos-lCurPos+1);
fread(lpszRearBlock, sizeof(char), lEndPos-lCurPos, IniFile); //从当前位置开始读其后面的文件内容(长度为lEndPos-lCurPos, 注意lEndPos是end结尾符号的位置,等于文件长度,比最大有效文件指针位置大1)
lpszFrontBlock = new char[lPrePos+1];
memset(lpszFrontBlock, 0, lPrePos+1);
fseek(IniFile, 0, SEEK_SET);
fread(lpszFrontBlock, sizeof(char), lPrePos, IniFile); //从头部开始读其后面的文件内容(长度为lPrePos,因为文件指针从0开始,lPrePos位置前的文件长度就是lPrePos)
//先关闭文件再用可写方式打开以清空原有内容，最后依次写文件的各个部分,如要不关闭
//打开文件而是直接清空文件内容,因unix和windows中设置文件长度的调用不同,比较麻烦
fclose(IniFile);
IniFile = fopen(lpszFileName, "wb"); //可写方式打开(如文件已存在,其所有内容被清空)
if(!IniFile) return FALSE;
fwrite(lpszFrontBlock, sizeof(char), lPrePos, IniFile);
fwrite(szKeyValBlock, sizeof(char), strlen(szKeyValBlock), IniFile);
fwrite(lpszRearBlock, sizeof(char), lEndPos-lCurPos, IniFile);
delete [] lpszFrontBlock;
delete [] lpszRearBlock;
bKeyFoundFlag = TRUE;
break;
}
}
//如果在指定段下未找到指定key,则要新建key=value对
if( !bKeyFoundFlag )
{
char szKeyBlock[2048];
memset(szKeyBlock, 0, 2048);
if(bMeetAnotherBlock) //遇到了另外一个段,此时要在该段前面插入新建的key=value对
{
sprintf(szKeyBlock, "%s = %s%s", lpszKeyName, lpszString, szLineEndStr);
//以下以lPrePos为界线将文件拆成两部分,和上面替换操作中lPrePos和lCurPos间内容
//不要不同,这里是插入而不是替换, 因此直接以lPrePos为界将文件分开,进行插入操作
fseek(IniFile, lPrePos, SEEK_SET); //定位到lPrePos(这里lPrePos是另一个段的开始字符,如"[")
lpszRearBlock = new char[lEndPos-lPrePos+1];
memset(lpszRearBlock, 0, lEndPos-lPrePos+1);
fread(lpszRearBlock, sizeof(char), lEndPos-lPrePos, IniFile); //从当前位置开始读其后面的文件内容(长度为lEndPos-lPrePos)
lpszFrontBlock = new char[lPrePos+1];
memset(lpszFrontBlock, 0, lPrePos+1);
fseek(IniFile, 0, SEEK_SET);
fread(lpszFrontBlock, sizeof(char), lPrePos, IniFile); //从头部开始读其后面的文件内容(长度为lPrePos)
//先关闭文件再用可写方式打开以清空原有内容，最后依次写文件的各个部分,如要不关闭
//打开文件而是直接清空文件内容,因unix和windows中设置文件长度的调用不同,比较麻烦
fclose(IniFile);
IniFile = fopen(lpszFileName, "wb"); //可写方式打开(如文件已存在,其所有内容被清空)
if(!IniFile) return FALSE;
fwrite(lpszFrontBlock, sizeof(char), lPrePos, IniFile);
fwrite(szKeyBlock, sizeof(char), strlen(szKeyBlock), IniFile);
fwrite(lpszRearBlock, sizeof(char), lEndPos-lPrePos, IniFile);
delete [] lpszFrontBlock;
delete [] lpszRearBlock;
}
else //如果连一个段都没有碰到，则肯定已到了文件尾部, 追加key=value块到尾部即可
{
fseek(IniFile, 0, SEEK_END);
/* 如当前位置前已有换行符号则无需另行增加,此举可防止新增部分和上面一行连在一起 */
if( IfBeforeHasRet(IniFile) )
sprintf(szKeyBlock, "%s = %s%s", lpszKeyName, lpszString, szLineEndStr);
else
sprintf(szKeyBlock, "%s%s = %s%s", szLineEndStr, lpszKeyName, lpszString, szLineEndStr);
fwrite(szKeyBlock, sizeof(char), strlen(szKeyBlock), IniFile);
}
}
func_end:
fclose(IniFile);
return true;
}
//辅助函数,判断文件中当前指针位置前面是否有换行符号,使用该函数前必须确保文件已经打开并将文件指针定位到应有的位置
bool IfBeforeHasRet(FILE* pFile)
{
char szTmp[3];
bool bBeforeHasRet = FALSE;
i_32 lOldPos;
memset(szTmp, 0, 3);
lOldPos = ftell(pFile); //保存文件当前指针位置
/* 读当前位置前面的两个字节, 因为windows下是回车换行两个字节 */
fseek(pFile, -2, SEEK_CUR);
fread(szTmp, sizeof(char), 2, pFile);
#ifdef OS_UNIX
if( szTmp[1] == 0x0a ) bBeforeHasRet = TRUE;
#else
if( szTmp[0] == 0x0d && szTmp[1] == 0x0a ) bBeforeHasRet = TRUE;
#endif
fseek(pFile, lOldPos, SEEK_SET); //恢复原先的文件指针位置
return bBeforeHasRet;
}
/*-----------------------------------工具函数----------------------------------*/
//从指定文件中读取一行
int ReadLineFromFile(FILE* IniFile, char* lpszLineBuf, int iLen)
{
int iPos;
/*-----------------------------------------------------------------------------
注意：如果文件以t即text方式打开，则回车换行两个字符在input时被当作一个字符处理，
因此fgets()得到的一行字符串尾部只有一个换行符而没有回车符，而如果是binary
方式打开则一行字符尾部同时有回车换行两个字符，打开方式的不同直接影响fgets
读入一行后删除行尾部控制字符的操作，如果是text方式，只要删除换行符号即可，
如果是binary方式，则要删掉两个控制字符。以下对两个控制字符是否存在都进行
判断，可以同时适应text和binary两种模式,也就能同时适应Windows下和Unix两种
不同格式的文本文件(unix文本文件行末只有一个换行符，即0A,没有回车符)
后续记录: fopen()中打开模式里的"t"是微软自己定义的，Ansi C 只支持 "b"模式
----------------------------------------------------------------------------*/
if(fgets(lpszLineBuf, iLen, IniFile) != NULL) //fgets()函数遇到第一个换行符(0x0A)后结束(包括换行符),然后在尾部追加一个NULL后返回,因此换行符总是倒数第二个字符
{
iPos = strlen(lpszLineBuf) - 1;
if( lpszLineBuf[iPos-1] == 0x0D ) lpszLineBuf[iPos-1] = 0; //删除尾部可能存在的回车符(0x0D)
if( lpszLineBuf[iPos] == 0x0A ) lpszLineBuf[iPos] = 0; //删除尾部可能存在的换行符(0x0A)
}
else
return -1;
return 0; //0表示正确
}
/*----------------------------------------------------------------------------
//从指定字符串中读取一行
int ReadLineFromString(char* lpszText, char* lpszLineBuf, int iLen)
{
int iPos;
if(fgets(lpszLineBuf, iLen, IniFile) != NULL) //fgets()函数遇到第一个换行符(0x0A)后结束(包括换行符),然后在尾部追加一个NULL后返回,因此换行符总是倒数第二个字符
{
iPos = strlen(lpszLineBuf) - 1;
if( lpszLineBuf[iPos-1] == 0x0D ) lpszLineBuf[iPos-1] = 0; //删除尾部可能存在的回车符(0x0D)
if( lpszLineBuf[iPos] == 0x0A ) lpszLineBuf[iPos] = 0; //删除尾部可能存在的换行符(0x0A)
}
else
return -1;
return 0; //0表示正确
}
---------------------------------------------------------------------------*/
//删除字符串的左侧空格, 2002.9.19增加删除TAB字符(ASC码为9)功能
void StrTrimLeft(char* szBuf)
{
char *szBak = NULL;
char *p = szBuf;
if(!szBuf) return;
while(*p == ' ' || *p == 9) { p++; }
//qDebug("StrtrimLeft:p=%s",p);
if(p != szBuf) //头部有空格或TAB字符
{
szBak = _strdup(p); //strcpy()中如source和dest重合(overlap)，则copy结果不可预料，故另设一个缓冲区临时存放这个头部没有空格的字符串
strcpy(szBuf, szBak); //strcpy()肯定不会溢出，因p是szBuf的一个子集，同时strcpy会拷贝结尾的null，因此无须人工截断szBuf
free(szBak);
}
}
//删除字符串的右侧空格, 2002.9.19增加删除TAB字符(ASC码为9)功能
void StrTrimRight(char* szBuf)
{
char *szBak = NULL;
int iPos = strlen(szBuf)-1; //最后一个非NULL字符的下标
if(!szBuf) return;
char *p = &szBuf[iPos];
while(*p == ' ' || *p == 9) { p--; }
if(p != &szBuf[iPos]) //尾部有空格
{
p++;
*p = 0; //直接尾部截断，比删除头部空格还简单
}
}
//删除左右两边所有空格
void StrTrimAll(char* szBuf)
{
StrTrimRight(szBuf);
StrTrimLeft(szBuf);
}
//获取指定文件的长度
i_32 GetFileSize(char* lpszFileName)
{
FILE* pFile;
pFile = fopen(lpszFileName, "rb"); //二进制方式
if(pFile == NULL) return -1;
fseek(pFile, 0, SEEK_END); //定位到文件尾部
i_32 lFileSize = ftell(pFile); //获取文件指针当前位置(此时文件指针指向EOF结束标志)[文件指针是从0开始计数的]
fclose(pFile);
return lFileSize;
}

1869
Profile_Hash.cpp
View File

File diff suppressed because it is too large Load Diff

514
Profile_Hash.h
Unescape Escape View File

@ -0,0 +1,514 @@
/******************************************************************************************
*
* 作者: m.j.y
*
* Pgc配置文件读写等操作--内部函数定义
*
* $Log: Profile_Hash.h,v $
* Revision 1.2 2006/08/04 03:37:33 zhuzhenhua
* no message
*
* Revision 1.1.2.1 2006/07/28 07:54:02 zhuzhenhua
* no message
*
* Revision 1.4 2003/07/14 01:56:23 scada
* 使用def文件导出函数
*
* Revision 1.3 2003/06/05 03:56:16 jehu
* 将注释修改为符合doxgen工具提取开发文档
*
* Revision 1.2 2002/12/04 07:47:36 scada
* for NT
*
* Revision 1.1.1.1 2002/08/21 07:16:37 harold
* temporarily import
*
* Revision 1.14 2002/06/03 10:07:04 mhorse
* 更改了宏的值
*
* Revision 1.13 2002/03/20 03:40:02 harold
* no message
*
* Revision 1.1.1.1 2002/03/15 13:43:18 harold
* no message
*
* Revision 1.1.1.1 2002/03/15 08:17:08 harold
* no message
*
* Revision 1.12 2002/01/23 05:27:39 harold
* no message
*
* Revision 1.11 2002/01/23 02:39:57 harold
* test_function
*
* Revision 1.10 2002/01/22 08:54:26 harold
* modify2002-01-22-16:46
*
* Revision 1.9 2002/01/21 12:58:49 harold
* no message
*
* Revision 1.8 2002/01/21 04:52:41 harold
* no message
*
* Revision 1.7 2002/01/18 12:56:14 harold
* revise errno
*
* Revision 1.6 1997/03/29 12:49:05 harold
* revise bug in read/write/listsec function
*
* Revision 1.5 2002/01/18 01:08:03 harold
* revise bugs in write/close/listsec function
*
* Revision 1.4 2002/01/16 09:49:41 harold
* no message
*
* Revision 1.3 2002/01/16 08:13:41 harold
* no message
*
* Revision 1.2 2002/01/09 09:42:40 harold
* no message
*
*
******************************************************************************************/
#ifndef profile_hashisdjfidsxxxxxxxxxxxxxijpsijfspo
#define profile_hashisdjfidsxxxxxxxxxxxxxijpsijfspo
/*!
* \if developer_doc
* \file
*
* \brief Pgc配置文件读写等操作--内部函数定义头文件。
*
* id: $Id: Profile_Hash.h,v 1.2 2006/08/04 03:37:33 zhuzhenhua Exp $
*
* \author 杨小波 prcharold@sina.com.cn develop1@szscada.com
* \endif
*/
//#include <util/util.h>
#include <string.h>
#include <stdio.h>
//#ifdef OS_LINUX
// #include <sys/time.h>
//#else
#include <winsock.h>
#include <time.h>
//#endif //OS_LINUX
#include "global_errno.h"
#include "typedef.h"
//#include "basetype.h"
#include "harximoban.h"
/*!
* \if by_group
* \addtogroup grp_config_rw
* @{
* \endif
*/
/*!
* 配置文件中, 每一行的最大长度
*/
#define MAX_CONF_LINE_L (1024)
//!< 定义每行(注释行的字符个数无限制）允许的最大字符个数, 包括换行符号'\r\n'及null字符
#define MAX_CHAR_LINE (MAX_CONF_LINE_L)
#ifndef PATH_MAX
#define PATH_MAX 260
#endif
#define MAX_PATH 260
//!< 定义存储文件路径的字符串数组的大小
#define MAX_PATH_NUM (MAX_PATH)
//在重新生成配置文件时，是否将'\r\n'作为行结束标志
//#define REWRITEFILE_ADDCHAR_13
//!< 设置缓冲区的最大段数
#define MAX_SEC_NUM 2500
//!< 设置缓冲区的每一段的最大项目个数
#define MAX_ITEM_NUM 30
//!< 定义初始化缓冲区容纳项目的个数
#define INITCACHE_ITEM_NUM 5000
//!< 缓冲区增大时的递增项目的个数
#define RESIZE_ITEM_NUM 5000
//!< 定义在一个进程中允许同时打开的配置文件缓冲句柄的个数
#define MAX_PROFILEHANDLE_NUM 50
//!< 定义配置文件缓冲句柄
typedef pgc32 HPROFILE;
//!< 保存注释的链表
typedef struct tagMemoChain
{
pgcchar *szMemo;
tagMemoChain * NextNode;
} SMemoChain;
//!< 缓冲项的结构
typedef struct tagItemInCache
{
pgcchar szItemName[MAX_CHAR_LINE];
pgcchar szItemVal[MAX_CHAR_LINE];
pgcchar szSecName[MAX_CHAR_LINE];
PGCBOOL valid;
PGCBOOL bIsSecName;
SMemoChain *memo;
tagItemInCache()
{
memset(this, 0, sizeof(*this));
}
} SItemInCache;
//!< 项目位置链表结构
typedef struct tagItemSequence
{
pgc32 iPos;
tagItemSequence *NextNode;
tagItemSequence()
{
memset(this, 0, sizeof(*this));
}
} SItemSequence;
//!< 定义存储句柄对应的信息的结构
typedef struct tagProfileHanleInfo
{
FILE *fstream;
//!< 保存配置文件全路径名
pgcchar szPathName[MAX_PATH_NUM];
//!< 配置文件上一次被修改的时间
timeval tLastModify;
//!< 哈希表指针
TChainHash<SItemInCache> *pHashTable;
//!< 行位置链表头指针
SItemSequence *pSequence;
//!< 行位置链表当前指针
SItemSequence *pCurSeq;
//!< 缓冲区数组入口
SItemInCache* pCacheEntry;
//!< 段总数
pgc32 CurSecNum;
//!< 当前缓冲区能容纳的项目个数
pgc32 CurItemCount;
//!< 已经使用的项目个数
pgc32 CurUseItems;
//!< 当前文件中的行数
pgc32 CurLines;
tagProfileHanleInfo()
{
memset(this, 0, sizeof(*this));
}
} SProfileHanleInfo;
/*!
* \brief 根据已知的历史数据库索引数组, 为其建立一个哈希表.
*
* \param pindex --[in] 索引数组的指针
* \param count --[in] pindex索引数组中索引的个数, pindex[0] -- pindex[count - 1]为索引
* \param pphash_of_index --[in] 将pindex所指向的数组哈希化, 这样, 在随后的索引搜索时, 使用该哈希索引.
*
* \retval SUCCESS -- 成功
* \retval 其它 -- 失败代码
*
*/
pgc32 profile_build_hash_index ( SItemInCache * pindex,
pgc32 count,
TChainHash<SItemInCache> ** pphash_of_index );
/*!
* \brief 在索引区中搜索
*
* \param pindex_base --[in] 被哈希化的索引数组的指针
* \param phash_of_index --[in] 索引数组的哈希表
* \param szSecName --[in] 被查询的段名
* \param szItemName --[in] 被查询的项目名
*
* \retval 索引在索引数组中的序号 -- 成功的查找到指定的配置项目的索引
* \retval -1 -- 失败
*/
pgc32 profile_search_sequence ( SItemInCache **pindex_base,
TChainHash<SItemInCache> *phash_of_index,
pgcchar *szSecName,
pgcchar *szItemName);
/*!
* \brief 判断某行是否被注释。
*
* \param szLine --[in] 行字串
*
* \retval PGCTRUE 是注释行
* \retval PGCFALSE 不是注释行
*/
PGCBOOL LineIsMark(pgcchar *szLine);
/*!
* \brief 寻找段尾。
*
* \param szString --[in] 字串
*
* \retval 字船指针 段尾的位置指针
* \retval NULL 没找到段尾
*/
pgcchar* FindSecTail(pgcchar *szString);
/*!
* \brief 提取段名。
*
* \param szString --[in] 需要提取段名的字串。
* \param szRevBuffer --[out] 段名字串缓冲，返回的段名保存在此。
* \param iBufferLength --[in] 段名字串缓冲空间的长度。
*
* \retval PGCTRUE 提取段名成功
* \retval PGCFALSE 提取段名失败
*/
PGCBOOL DigSecName(const pgcchar *szString, pgcchar *szRevBuffer, pgc32 iBufferLength);
/*!
* \brief 提取项目名及项目值。
*
* \param szString --[in] 需要提取项目名及项目值的字串。
* \param szItemName --[in] 行字符串头指针。
* \param szItemVal --[out] 项目值字串缓冲，返回的项目值保存在此。
* \param iBufferLength --[in] 项目值字串空间的长度。
*
* \retval PGCTRUE 成功
* \retval PGCFALSE 失败
*/
PGCBOOL DigItemContent( pgcchar *szString, pgcchar *szItemName, pgcchar *szItemVal, pgc32 iBufferLength);
/*!
* \brief 添加一个节点到顺序链表中。
*
* \param psHead --[in] 顺序链表头节点的指针。
* \param iPos --[in] 该节点要保存的缓冲数组的偏移位置。
*
* \retval PGCTRUE 成功
* \retval PGCFALSE 失败
*/
PGCBOOL AddNode(SItemSequence * &psHead, pgc32 iPos);
/*!
* \brief 释放配置文件缓冲句柄。
*
* \param hProfile --[in] 配置文件缓冲句柄。
*/
void ReleaseProfileCache(HPROFILE hProfile);
/*!
* \brief 重写配置文件。
*
* \param hProfile --[in] 配置文件缓冲句柄。
*
* \retval SUCCESS 成功。
* \retval 其它 失败，错误代码。
*/
pgc32 ReWriteProfile(HPROFILE hProfile);
/*!
* \brief 创建文件句柄缓冲。
*
* \param hProfile --[in] 配置文件缓冲句柄。
*
* \retval SUCCESS 成功。
* \retval 其它 失败，错误代码。
*/
pgc32 ProcessCreateCache(HPROFILE hProfile);
//-----------------------------------------------------------------------------------------
/*!
*\verbatim
//以下为应用接口
******************************************************************************************
*
* 作者: m.j.y
*
* Pgc读配置文件--外部函数定义（供外部调用人员使用）
*
******************************************************************************************
*\endverbaim
*/
/*!
* \brief 建立配置文件缓冲。
*
* \param szProfileName --[in] 配置文件全路径名。
* \param phfile --[out] 如果函数执行成功，则返回一个句柄。
*
* \retval SUCCESS -- 成功建立配置文件缓冲。
* \retval 失败则返回具体的执行失败的代码。
* \retval ERROR_CONF_NOHANDLE -- 建立配置文件缓冲失败，原因：没有空闲的配置文件缓冲句柄分配给当前配置文件缓冲。
* \retval ERROR_FOPEN -- 打开文件失败。
* \retval ERROR_FREAD -- 读文件失败。
* \retval ERROR_CONF_CREATEHASH -- 建立哈希表失败。
* \retval ERROR_MEMORY_ALLOC -- 不能不能分配指定大小的内存。
*/
int create_profile_cache(pgcchar *szProfileName, int *phfile);
/*!
* \brief 关闭配置文件缓冲。
*
* 函数逻辑：根据在该配置文件缓冲句柄中记录的信息，释放资源.
*
* \param hProfile --[in] 配置文件缓冲句柄。
*
* \retval SUCCESS -- 成功。
* \retval 失败则返回具体的执行失败的代码。
* \retval ERROR_CONF_INVALIDHANDLE -- 输入了非法的配置文件缓冲句柄。
*/
int close_profile_handle(HPROFILE hProfile);
/*!
* \brief 根据段名，项目名获取项目值。
*
* 函数逻辑:调用者通过参数lpAppName， lpKeyName传入要取出的项目值所在的段名和项目名，
* 如果指定的段及项目名存在，函数将取出的项目值拷贝到以lpReturnedString为首地址的
* 目标缓冲中(目标缓冲的长度通过指针pdwSize传入)，随后函数会将取出的项目值
* 的长度(包括'\0'字符)写入地址指针pdwSize中； 如果指定的段及项目名不存在，则执行缺省拷贝，即将
* lpDefault 所指向的字符串拷贝到目标缓冲区lpReturnedString中; 如果目标缓冲区的首地址
* lpReturnedString为空或传入的目标缓冲的长度小于1，那么函数不会将任何字符串拷贝到
* 目标缓冲，但是仍会将取出的项目值的长度(包括'\0'字符)写入地址指针pdwSize中。
*
* \param lpAppName --[in] 段名。
* \param lpDefault --[in] 当获取指定的项目值失败时，将该缓冲区的字符串写入lpReturnedString目标缓冲。
* \param lpReturnedString --[out] 目标缓冲区，用来存放取出的项目值。
* \param pdwSize --[in][out] 指向缓冲区的长度的指针，同时在调用结束后，将取出的项目字符串的长度(包括'\0'字符)写入该地址。
* \param hProfile --[in] 配置文件缓冲句柄。
*
* \retval SUCCESS -- 成功，如果指定的段及项目名存在，函数将取出的项目值拷贝到以lpReturnedString为首地址的
* 目标缓冲中，如果取出的项目值的长度小于或等于目标缓冲区的长度，那么整个项目值将被完全拷贝到目标缓冲中，此时函数返回SUCCESS。
* \retval ERROR_CONF_REVBUFFER -- 如果指定的段及项目名存在,但是取出的项目值的长度大于目标缓冲区的长度,
* 那么取出的项目值将被截断为和目标缓冲区一样的大小，然后再拷贝到目标缓区，此时函数返回ERROR_CONF_REVBUFFER。
* \retval SUCCESS_CONF_DEFCOPY -- 如果指定的段及项目名不存在，并且lpDefault指针不为空，则函数将lpDefault所指向的字符串拷贝到目标缓冲区lpReturnedString，
* 如果lpDefault指向的字符串的长度大于目标缓冲区的长度，那么只从lpDefault开始拷贝 [目标缓冲区的长度 － 1]个字符到缓冲中。
* \retval ERROR_CONF_INVALIDHANDLE -- 输入了非法的配置文件缓冲句柄。
* \retval ERROR_FAIL -- 函数执行失败，即未拷贝任何字符到目标缓冲区。
*/
int get_pgcprofile_string(
const pgcchar * lpAppName, // points to section name
const pgcchar * lpKeyName, // point to key name
const pgcchar * lpDefault, // point to default string
pgcchar * lpReturnedString, // point to destination buffer
pgcu32 * pdwSize, // point to size of destination buffer
HPROFILE hProfile // point to initialization filename
);
/*!
* \brief 根据段名，项目名写项目值。
*
* 函数逻辑: 调用者通过参数lpAppName， lpKeyName传入要写入的项目值所在的段名和项目名，
* 如果指定的段及项目名存在，函数将把lpString所指向的以空字符结尾的字符串拷贝到
* 以该段名，项目名对应的项目值缓冲中，然后再把整个配置文件缓冲的内容写入到文件中,
* 并返回SUCCESS;如果指定的段及项目名不存在，函数会根据参数bInsertItem的值决定是否将输入的段名以及
* 项目名添加到配置文件中，如果bInsertItem为真，则添加该段名和项目名，然后写入项目值，
* 并返回SUCCESS; 如果bInsertItem为假，函数返回ERROR_FAIL。
*
* \param lpAppName --[in] 段名
* \param lpKeyName --[in] 项目名
* \param lpString --[in] 要写入的字符串
* \param hProfile --[in] 配置文件缓冲句柄
* \param bInsertItem --[in] 当指定的段名或项目名不存在时，是否添加该段或项目；PGCTRUE-添加；PGCFALSE-不添加（缺省）
*
* \retval SUCCESS(0) -- 如果指定的段及项目名存在，函数将把lpString所指向的以空字符结尾的字符串拷贝到
* 以该段名，项目名对应的项目值缓冲中，然后再把整个配置文件缓冲的内容写入到文件中,并返回SUCCESS
* \retval ERROR_FWRITE -- 写文件错误
* \retval ERROR_CONF_INVALIDHANDLE -- 输入了非法的配置文件缓冲句柄
* \retval ERROR_FAIL -- 函数执行失败，即未将任何字符写到配置文件缓冲区以及文件
*/
int write_pgcprofile_string(
const pgcchar * lpAppName, // point to section name
const pgcchar * lpKeyName, // point to key name
const pgcchar * lpString, // point to string to add
HPROFILE hProfile, // handle to Profile Cache
PGCBOOL bInsertItem
);
/*!
* \brief 获取配置文件的所有段名。
*
* 函数逻辑：将从配置文件中获取的段名按在文件中出现的先后次序写到pdwSize所指向的地址空间，
* 每个段名以一个空字符作为结束标志，在最后一个段名的结尾处再多加一个空字符
* 作为所有全部段名的结束标志，即内存格式为 ：段名1\0段名2\0......最后一个段名\0\0
*
* \param lpszReturnBuffer --[out] 写入缓冲区。
* \param pdwSize --[in][out] 写入缓冲区的按字节长度。
* \param nSecNum --[out] 将获取的段总数写入该地址。
* \param hProfile --[in] handle to Profile Cache
*
* \retval SUCCESS -- 成功
* \retval 其它 -- 失败则返回具体的执行失败的代码
*/
int get_pgcprofile_secnames(
pgcchar * lpszReturnBuffer, // address of return buffer
pgcu32 * pdwSize, // size of return buffer
pgcu32 *nSecNum,
HPROFILE hProfile // handle to Profile Cache
);
/*!
* \brief 删除指定的项目。
*
* 函数逻辑：在缓冲中删除指定的项目，以及该项目上方的注释，然后以覆盖方式重写文件。
*
* \param lpAppName --[in] 段名
* \param lpKeyName --[in] 项目名
* \param hProfile --[in] 配置文件的缓冲句柄
*
* \retval SUCCESS -- 成功
* \retval 其它 -- 失败则返回具体的执行失败的代码
*/
int del_pgcprofile_key( const pgcchar * lpAppName, // point to section name
const pgcchar * lpKeyName, // point to key name
HPROFILE hProfile // point to initialization filename
);
/*!
* \brief 删除指定的段。
*
* 函数逻辑：在缓冲中删除指定的段，以及该段上方的注释，然后以覆盖方式重写文件；
* 在删除一个段的同时，该段下属的所有项目（包括项目上方的注释）将被删除。
*
* \param lpAppName --[in] 段名
* \param hProfile --[in] 配置文件的缓冲句柄
*
* \retval SUCCESS -- 成功
* \retval 其它 -- 失败则返回具体的执行失败的代码
*/
int del_pgcprofile_sec( const pgcchar * lpAppName,
HPROFILE hProfile
);
/*!
* \brief 时间比较, 并返回其差值的绝对值
*
* \param ptv1 --[in] 时间1
* \param ptv2 --[in] 时间2
* \param ptv_abs_delta --[out] 返回差值的绝对值, 如果该参数不为0.
*
* \retval 小于0 -- ptv1 小于(早于) ptv2
* \retval 等于0 -- ptv1 等于(等于) ptv2
* \retval 大于0 -- ptv1 大于(晚于) ptv2
*/
int timeval_compare (
const timeval * ptv1,
const timeval * ptv2,
timeval * ptv_abs_delta = 0 );
/*!
* \if by_group
* @}
* \endif
*/
#endif

13
_confrw.h
Unescape Escape View File

@ -0,0 +1,13 @@
#if !defined(___CONFRW_H__DASJFHNZVCKZLCVHASPFDUIWQERJADHBNCBJADJFJDJAHFLWEJAHDSLFHLA)
#define ___CONFRW_H__DASJFHNZVCKZLCVHASPFDUIWQERJADHBNCBJADJFJDJAHFLWEJAHDSLFHLA
//#include <util/util.h>
#include "confrw_errno.h"
#include "confrw.h"
//#include "Profile_Hash.h"
#endif //!defined(___CONFRW_H__DASJFHNZVCKZLCVHASPFDUIWQERJADHBNCBJADJFJDJAHFLWEJAHDSLFHLA)

77
baohua.h
Unescape Escape View File

@ -0,0 +1,77 @@
#ifndef __BAOHU_A_H_H_ICL__
#define __BAOHU_A_H_H_ICL__
#include "common.h"
// 设备信息定义
#define DEVIVE_NAME "CAC-SERVER"
#define VERSION "V1.00"
#define VERSION_DATE "2023-11-10"
#define MANUFACTURER "Global CAC"
extern SIO_PARAM_DEF SioParam[];
extern FUNCTION_CALL *FunCallPtr;
extern u_short MaxSerialPortNum;
extern u_short MaxNetPortNum;
extern u_short MaxPortNum;
extern void *pvconf_handle;
extern void *pvportconf_handle;
extern void *pvdataconf_handle;
extern char pvDataFileName[256];
extern char DeviceName[];
extern char Version[];
extern char VersionDate[];
extern char Manufacturer[];
extern char IniFilePath[256];
extern DAY_TIME DayTime;
void ByPassRecvData( int commid, u_char *buf, int len );
void WatchPortRecvData( void );
// 从 config.ini 或 portconfig.ini 读信息
u_long GetPrivateProString( char * section, char * entry, char * deflautstr, char * reslut,int len, char *inifile );
u_long atoul( u_char *buf );
int SetPntMsg( int port, int point, void *pntmsg, BYTE type, BYTE attr );
int GetPntMsg( int port, int point, void *pntmsg, BYTE type, BYTE attr );
int SetPorvPntMsg( int port, int point, void *pntmsg, BYTE type, BYTE attr );
int GetPorvPntMsg( int port, int point, void *pntmsg, BYTE type );
int CheckPollCmdBufEmpty( int port );
int PutPollCmdToBuf( int port, int type, WORD wait, char *buf, int len );
void PortMemeryMalloc( int port, int type );
void YkYtCommandProcess( int port, u_char *buf, int len );
// 读设备信息，检查芯片状态和读芯片类型和频率
void ReadPortConfigInfo( u_short netport );
void DataDisp( HWND );
void CloseUdpSetSock( void );
void PageUp( void );
void PageDown( void );
void PageHome( void );
void PageEnd( void );
void LineUp( void );
void LineDown( void );
void OpenAllPort( void );
void CloseOnePort( int commid );
void CloseAllPort( void );
void PollAllSerialPort( void );
void PollAllNetPort( void );
void TimerProc( void );
void SystemRtuTime( void );
#endif

922
basefunc.cpp
Unescape Escape View File

@ -0,0 +1,922 @@
//#ifdef OS_WINDOWS
#include <windows.h>
#include <direct.h>
#include <process.h>
/*#else
#include <sys/time.h>
#endif*/
#include <stdio.h>
#include <time.h>
#include <fcntl.h>
#include "basefunc.h"
extern char IniFilePath[256];
void DebugPrint(char *szDebug)
{
//#ifdef OS_WINDOWS
OutputDebugString((WCHAR*)szDebug);
OutputDebugString((WCHAR*)"\n");
//#else
// printf("%s\n", szDebug);
//#endif
}
int CmpString(const u_char *str1, const u_char *str2)
{
size_t i, len;
len = strlen((char*)str1);
if(len != strlen((char*)str2))
{
return 0;
}
for (i = 0; i < len; i++)
{
if(toupper(str1[i]) != toupper(str2[i]))
{
return 0;
}
}
return 1;
}
int CmpString2(const char *str1, const char *str2)
{
size_t i, len;
len = strlen(str1);
if(len != strlen(str2))
{
return 0;
}
for (i = 0; i < len; i++)
{
if(toupper(str1[i]) != toupper(str2[i]))
{
return 0;
}
}
return 1;
}
BOOL IsRemarkLine(const char *str)
{
int i, iLen;
BOOL bRetVal;
bRetVal = FALSE;
iLen = strlen(str);
for(i=0; i<iLen-1; i++)
{
if(str[i] == 0x20)
{
continue;
}
if(str[i] == '#')
{
bRetVal = TRUE;
}
else if(str[i] == ';')
{
bRetVal = TRUE;
}
//else if((str[i] == '\/') && (str[i+1] == '\/'))
else if((str[i] == '/') && (str[i+1] == '/'))
{
bRetVal = TRUE;
}
break;
}
return bRetVal;
}
void SwapByteSequence(char *pData, int ilen)
{
int i, count;
char tmp;
count = (ilen+1)/2;
for(i=0; i<count; i++)
{
tmp = pData[ilen-i-1];
pData[ilen-i-1] = pData[i];
pData[i] = tmp;
}
}
BOOL IsNetSequence()
{
char *ptr;
short iValue;
ptr = (char *)&iValue;
iValue = 0x55AA;
if(ptr[0] == 0x55)
return TRUE;
else
return FALSE;
}
BOOL SequenceHostToRtu(char *pData, int ilen)
{
int i;
char buf[32];
if(ilen > sizeof(buf))
return FALSE;
if( IsNetSequence() )
{
for( i=0; i<ilen; i++ )
{
buf[i] = pData[ilen-i-1];
}
memcpy(pData, buf, ilen);
}
return TRUE;
}
BOOL SequenceRtuToHost(char *pData, int ilen)
{
return SequenceHostToRtu(pData, ilen);
}
BOOL SequenceHostToNet(char *pData, int ilen)
{
int i;
char buf[32];
if(ilen > sizeof(buf))
{
return FALSE;
}
if(IsNetSequence() == FALSE)
{
for( i=0; i<ilen; i++ )
{
buf[i] = pData[ilen-i-1];
}
memcpy(pData, buf, ilen);
}
return TRUE;
}
BOOL SequenceNetToHost(char *pData, int ilen)
{
return SequenceHostToNet(pData, ilen);
}
WORD SequenceRtuToHostWord(WORD wValue)
{
WORD retval;
retval = wValue;
SequenceRtuToHost((char *)&retval, sizeof(WORD));
return retval;
}
WORD SequenceHostToRtuWord(WORD wValue)
{
WORD retval;
retval = wValue;
SequenceHostToRtu((char *)&retval, sizeof(WORD));
return retval;
}
DWORD SequenceRtuToHostDWord(DWORD dwValue)
{
DWORD retval;
retval = dwValue;
SequenceRtuToHost((char *)&retval, sizeof(DWORD));
return retval;
}
DWORD SequenceHostToRtuDWord(DWORD dwValue)
{
DWORD retval;
retval = dwValue;
SequenceHostToRtu((char *)&retval, sizeof(DWORD));
return retval;
}
int SequenceRtuToHostint(int iValue)
{
int retval;
retval = iValue;
SequenceRtuToHost((char *)&retval, sizeof(int));
return retval;
}
int SequenceHostToRtuint(int iValue)
{
int retval;
retval = iValue;
SequenceHostToRtu((char *)&retval, sizeof(int));
return retval;
}
long SequenceRtuToHostlong(long lValue)
{
long retval;
retval = lValue;
SequenceRtuToHost((char *)&retval, sizeof(long));
return retval;
}
long SequenceHostToRtulong(long lValue)
{
long retval;
retval = lValue;
SequenceHostToRtu((char *)&retval, sizeof(long));
return retval;
}
float SequenceRtuToHostfloat(float fValue)
{
float retval;
retval = fValue;
SequenceRtuToHost((char *)&retval, sizeof(float));
return retval;
}
float SequenceHostToRtufloat(float fValue)
{
float retval;
retval = fValue;
SequenceHostToRtu((char *)&retval, sizeof(float));
return retval;
}
double SequenceRtuToHostdouble(double dbValue)
{
double retval;
retval = dbValue;
SequenceRtuToHost((char *)&retval, sizeof(double));
return retval;
}
double SequenceHostToRtudouble(double dbValue)
{
double retval;
retval = dbValue;
SequenceHostToRtu((char *)&retval, sizeof(double));
return retval;
}
//********************************************************************
//* 获取系统时间函数 *
//*参数： DAY_TIME : 系统时间缓冲区 *
//*返回值：BOOL retval : 是否成功 *
//********************************************************************
BOOL GetLocalTimeEx(DAY_TIME *ptrDateTime)
{
int msec;
struct tm *tmptr=NULL;
time_t tm_t;
/*#if OS_LINUX
struct timeval timeval;
gettimeofday(&timeval, NULL);
msec = timeval.tv_usec/1000;
#elif OS_WINDOWS*/
SYSTEMTIME sm;
GetLocalTime(&sm);
msec = sm.wMilliseconds;
/*#else
msec = 0;
#endif*/
tm_t = time(NULL);
// 格林威治时间
//tmptr = gmtime(&tm_t);
// 本地时间
localtime_s(tmptr, &tm_t);
if(!tmptr)
{
return FALSE;
}
ptrDateTime->Year = tmptr->tm_year + 1900;
ptrDateTime->Month = tmptr->tm_mon + 1;
ptrDateTime->Day = tmptr->tm_mday;
ptrDateTime->Hour = tmptr->tm_hour;
ptrDateTime->Min = tmptr->tm_min;
ptrDateTime->Sec = tmptr->tm_sec;
ptrDateTime->mSec = msec;
ptrDateTime->WeekDay = tmptr->tm_wday;
ptrDateTime->MonthDay = tmptr->tm_mday;
return TRUE;
}
//********************************************************************
//* 设置系统时间函数 *
//*参数： DAY_TIME : 时间缓冲区 *
//*返回值：BOOL retval : 是否成功 *
//********************************************************************
//BOOL SetLocalTimeEx(DAY_TIME *ptrDateTime)
void SetLocalTimeEx(DAY_TIME *ptrDateTime)
{
#/*if OS_LINUX
//int ret;
//pid_t pid;
//char szCmdLine[256];
//sprintf(szCmdLine, "date %02d%02d%02d%02d%04d.%02d",
// ptrDateTime->Month,
// ptrDateTime->Day,
// ptrDateTime->Hour,
// ptrDateTime->Min,
// ptrDateTime->Year,
// ptrDateTime->Sec);
//pid = vfork();
//if(pid == 0)
//{
// ret = system (szCmdLine); //执行date命令设置时间
// exit(0);
// //return exit(0);
// //if(ret == 0)
// //return TRUE;
// //else
// // return FALSE;
//}
////else return TRUE;
struct tm tm_st;
time_t tm_t;
tm_st.tm_year = ptrDateTime->Year - 1900;
tm_st.tm_mon = ptrDateTime->Month - 1;
tm_st.tm_mday = ptrDateTime->Day;
tm_st.tm_hour = ptrDateTime->Hour;
tm_st.tm_min = ptrDateTime->Min;
tm_st.tm_sec = ptrDateTime->Sec;
//printf("TIP_(%04d): %02d/%02d/%04d_%02d:%02d:%02d.\n",
// getpid(), tm_st.tm_mon+1, tm_st.tm_mday, tm_st.tm_year+1900,
// tm_st.tm_hour, tm_st.tm_min, tm_st.tm_sec);
tm_t = mktime(&tm_st);
if(tm_t > 0)
{
stime(&tm_t);
//printf("TIP_(%04d): set time is ok.\n", getpid());
}
#else */ //windows
SYSTEMTIME systime;
BOOL bRetVal;
systime.wYear = ptrDateTime->Year;
systime.wMonth = ptrDateTime->Month;
//systime.wDayOfWeek = ptrDateTime->wDayOfWeek;
systime.wDay = ptrDateTime->Day;
systime.wHour = ptrDateTime->Hour;
systime.wMinute = ptrDateTime->Min;
systime.wSecond = ptrDateTime->Sec;
systime.wMilliseconds = ptrDateTime->mSec;
bRetVal = SetLocalTime(&systime);
//if(!bRetVal) return FALSE;
//else return TRUE;
//#endif
}
_int64 SystemTimeToMillseconds(DAY_TIME *lpTime, int i8HourOffset)
{
_int64 iMilliseconds;
time_t iTime;
struct tm changetm;
//struct tm *testtm;
iMilliseconds=0;
changetm.tm_hour = lpTime->Hour;
changetm.tm_mday = lpTime->Day;
changetm.tm_min = lpTime->Min;
changetm.tm_mon = lpTime->Month - 1;
changetm.tm_sec = lpTime->Sec;
changetm.tm_year = lpTime->Year - 1900;
changetm.tm_isdst = -1;
iTime = mktime(&changetm);
//testtm = localtime( &iTime );
if(iTime == (time_t)-1)
return 0;
iMilliseconds = iTime - i8HourOffset * 3600 * 8;
iMilliseconds = iMilliseconds*1000 + lpTime->mSec;
return iMilliseconds;
}
void LogRunRecord(char *pstrLogMsg, char *pstrfilename)
{
int ilen;
DAY_TIME sCurtime;
char szFileName[256];
//#if OS_WINDOWS
FILE *fp;
GetLocalTimeEx(&sCurtime);
//getcwd(szFileName, sizeof(szFileName)-16);
if(pstrfilename == NULL)
{
sprintf(szFileName, "%s/%04d%02d%02d.log", IniFilePath, sCurtime.Year, sCurtime.Month, sCurtime.Day);
}
else
{
ilen = strlen(pstrfilename);
if((ilen < 3) || (ilen >= (sizeof(szFileName)-1)))
{
sprintf(szFileName, "%s/%04d%02d%02d.log", IniFilePath,
sCurtime.Year, sCurtime.Month, sCurtime.Day);
}
else
{
strcpy(szFileName, pstrfilename);
}
}
fp = fopen(szFileName, "ab");
if(fp != NULL)
{
fwrite(pstrLogMsg, sizeof(char), strlen(pstrLogMsg)+1, fp);
fclose(fp);
}
/*#else
int fp;
GetLocalTimeEx(&sCurtime);
if(pstrfilename == NULL)
{
sprintf(szFileName, "/log/%04d%02d%02d.log", IniFilePath,
sCurtime.Year, sCurtime.Month, sCurtime.Day);
}
else
{
ilen = strlen(pstrfilename);
if((ilen < 3) || (ilen >= (sizeof(szFileName)-1)))
{
sprintf(szFileName, "/log/%04d%02d%02d.log", IniFilePath,
sCurtime.Year, sCurtime.Month, sCurtime.Day);
}
else
{
strcpy(szFileName, pstrfilename);
}
}
fp = open(szFileName, O_CREAT|O_RDWR|O_APPEND);
if(fp < 0)
{
printf("TIP_(%04d): open %s is Failed.\n", getpid(), szFileName);
}
else
{
ilen = strlen(pstrLogMsg);
write(fp, pstrLogMsg, ilen);
close(fp);
}
#endif*/
}
BOOL CheckTcpIpAddr(char *addr)
{
int d;
char *ptr;
if(strlen(addr) < 7)
return FALSE;
if(strlen(addr) > 20)
return FALSE;
d = atoi(addr);
if((d < 0) || (d > 255))
{
return FALSE;
}
ptr = strstr(addr, ".");
if(ptr == NULL)
{
return FALSE;
}
ptr++;
d = atoi(ptr);
if((d < 0) || (d > 255))
{
return FALSE;
}
ptr = strstr(ptr, ".");
if(ptr == NULL)
{
return FALSE;
}
ptr++;
d = atoi(ptr);
if((d < 0) || (d > 255))
{
return FALSE;
}
ptr = strstr(ptr, ".");
if(ptr == NULL)
{
return FALSE;
}
ptr++;
d = atoi(ptr);
if((d < 0) || (d > 255))
{
return FALSE;
}
return TRUE;
}
WORD CalCheckout(u_char *buf, int len)
{
int i;
WORD sum;
sum = 0;
for(i = 0; i < len; i++)
{
sum += buf[i];
}
return sum;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// wen 2005.10.19 增加基本函数
int IsHexChar(u_char c)
{
if((c >= '0') && (c <= '9'))
return 1;
if((c >= 'A') && (c <= 'F'))
return 1;
if((c >= 'a') && (c <= 'f'))
return 1;
return 0;
}
int HexToDec(u_char c)
{
if((c >= '0') && (c <= '9'))
return (c - '0');
if((c >= 'A') && (c <= 'F'))
return (c - 'A' + 10);
if((c >= 'a') && (c <= 'f'))
return (c - 'a' + 10);
return 0;
}
u_long atoul(char *buf)
{
int j, len;
u_long val;
char szbuf[256];
if(!buf)
return 0;
if(strlen(buf) == 0)
return 0;
if(buf[0] != '-')
strcpy(szbuf, buf);
else
strcpy(szbuf, &buf[1]);
val = 0;
len = strlen(szbuf);
if((szbuf[0] == '0') && ((szbuf[1] == 'x')||(szbuf[1]=='X')))
{
for(j = 2; j < len; j++)
{
if(IsHexChar(szbuf[j]) == 0)
break;
val = val * 16 + HexToDec(szbuf[j]);
}
}
else
{
for(j = 0; j < len; j++)
{
if((szbuf[j] < '0') || (szbuf[j] > '9'))
break;
val = val*10 + (szbuf[j] - '0');
}
}
return val;
}
/* !
\brief 删除字符串中的空格、制表符以及注释符
\param str[in/out] -- 要删除的字符串指针
\返回值 retval-- 处理后的字符串长度
*/
int StringCutSpace(char *str)
{
int i, j, flag, len;
char *ptr;
if(!str)
return 0;
len = (int)strlen(str);
if(len == 0)
return 0;
j = 0;
flag = 0;
for(i = 0; i < len; i++)
{
// 在双引号" "中的字符串不进行去空格和制表符的处理
if(str[i] == '\"')
{
flag = flag ? 0 : 1;
continue;
}
if(flag == 0)
{
if((str[i] == ' ') || (str[i] == '\t'))
continue;
}
str[j++] = str[i];
}
str[j] = 0;
ptr = strstr(str, "//");
if(ptr != NULL)
*ptr = 0x00;
ptr = strstr(str, "/*");
if(ptr != NULL)
*ptr = 0x00;
ptr = strstr(str, "\n");
if(ptr != NULL)
*ptr = 0x00;
ptr = strstr(str, "\r");
if(ptr != NULL)
*ptr = 0x00;
ptr = strstr(str, "#");
if(ptr != NULL)
*ptr = 0x00;
return strlen(str);
}
void StringToUpper(char *buf)
{
int i, len;
if(!buf)
return;
len = strlen(buf);
for(i = 0; i < len; i++)
{
//buf[i] = toupper(buf[i]);
if((buf[i] >= 'a') && (buf[i] <= 'z'))
{
buf[i] -= 32;
}
}
//printf("wen: Upperchar=%s\n", buf);
}
void StringToLower(char *buf)
{
int i, len;
if(!buf)
return;
len = strlen(buf);
for(i = 0; i < len; i++)
{
//buf[i] = tolower(buf[i]);
if((buf[i] >= 'A') && (buf[i] <= 'Z'))
{
buf[i] += 32;
}
}
//printf("wen: Lowerchar=%s\n", buf);
}
void PrintFormatMessage(int iMsgClass, char *ptrMsg)
{
/*
int ilen;
char szMsg[256];
if(ptrMsg == NULL)
{
return;
}
ilen = strlen(ptrMsg);
if(ilen > 200)
{
ptrMsg[200] = 0;
}
switch(iMsgClass)
{
// !输出信息级别为警告信息
case MSG_CLASS_WARN:
sprintf(szMsg, "WARN(%04d): %s\n", getpid(), ptrMsg);
break;
/* !输出信息级别为错误信息
case MSG_CLASS_ERROR:
sprintf(szMsg, "ERR_(%04d): %s\n", getpid(), ptrMsg);
break;
/* !输出信息级别为提示信息
case MSG_CLASS_TIP:
default:
sprintf(szMsg, "TIP_(%04d): %s\n", getpid(), ptrMsg);
break;
}
#ifdef OS_WINDOWS
OutputDebugString(szMsg);
#else
printf("%s", szMsg);
#endif*/
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// 超时判断
BOOL JudgeTimeOut(DAY_TIME *pStartTime, int iTimeOutSeconds)
{
int iDays, iVal1, iVal2;
int iAllSeconds;
DAY_TIME sCurTime;
GetLocalTimeEx(&sCurTime);
iDays = sCurTime.Day - pStartTime->Day;
if((iDays < 0) || abs(iDays) > 1)
{
return TRUE;
}
iVal1 = sCurTime.Hour*3600 + sCurTime.Min*60 + sCurTime.Sec;
iVal2 = pStartTime->Hour*3600 + pStartTime->Min*60 + pStartTime->Sec;
iAllSeconds = iVal1 - iVal2;
if(iAllSeconds < 0)
{
iAllSeconds += 24*3600;
}
if(iAllSeconds < iTimeOutSeconds)
{
return FALSE;
}
return TRUE;
}
// CRC校验表计算函数
void CalcCRCTableEx(WORD *pwCrcTable, WORD wDivisor)
{
int i, j, k;
WORD ench;
for ( i = 0; i < 256; i++ )
{
ench = 0;
for(k=0; k<8; k++)
{
if(i & (0x01<<k))
ench |= (0x8000>>k);
}
for ( j = 0; j < 8; j++ )
{
if ( (ench & 0x8000) != 0 )
{
ench = ench << 1;
ench = ench ^ wDivisor;
}
else
{
ench = ench << 1;
}
}
pwCrcTable[i]=0;
for(k=0; k<16; k++)
{
if(ench & (0x0001<<k))
pwCrcTable[i] |= (0x8000>>k);
}
}
}
// 计算校验和
BYTE CalcAllDataLpc(BYTE *pData, int iLen)
{
int i;
BYTE retval;
retval = pData[0];
for(i=1; i<iLen; i++)
{
retval += pData[i];
}
return retval;
}
WORD CalcAllDataLpcW(BYTE *pData, int iLen)
{
int i;
WORD retval;
retval = pData[0];
for(i=1; i<iLen; i++)
{
retval += pData[i];
}
return retval;
}

46
basefunc.h
Unescape Escape View File

@ -0,0 +1,46 @@
//
//////////////////////////////////////////////////////////////////////
#if !defined(_BASEFUNC_H_200506101543__INCLUDED_)
#define _BASEFUNC_H_200506101543__INCLUDED_
#include "basetype.h"
DSLIB_API void DebugPrint(char *szDebug);
// 字符串操作
DSLIB_API int CmpString(const u_char *str1, const u_char *str2);
DSLIB_API int CmpString2(const char *str1, const char *str2);
BOOL IsRemarkLine(const char *str);
// 字节转换
/*! RTU字节顺序为低字节在前，高字节在后
NET字节顺序为高字节在前，低字节在后
*/
DSLIB_API BOOL IsNetSequence();
DSLIB_API BOOL SequenceHostToRtu(char *pData, int ilen);
DSLIB_API BOOL SequenceRtuToHost(char *pData, int ilen);
DSLIB_API BOOL SequenceHostToNet(char *pData, int ilen);
DSLIB_API BOOL SequenceNetToHost(char *pData, int ilen);
// 超时判断
BOOL JudgeTimeOut(DAY_TIME *pStartTime, int iTimeOutSeconds);
BOOL GetLocalTimeEx(DAY_TIME *ptrDateTime);
void SetLocalTimeEx(DAY_TIME *ptrDateTime);
float SequenceRtuToHostfloat(float fValue);
_int64 SystemTimeToMillseconds(DAY_TIME *lpTime, int i8HourOffset);
float SequenceHostToRtufloat(float fValue);
int StringCutSpace(char *str);
u_long atoul(char *buf);
void StringToUpper(char *buf);
void StringToLower(char *buf);
void PrintFormatMessage(int iMsgClass, char *ptrMsg);
void SwapByteSequence(char *pData, int ilen);
BOOL CheckTcpIpAddr(char *addr);
WORD SequenceHostToRtuWord(WORD wValue);
WORD SequenceRtuToHostWord(WORD wValue);
WORD CalCheckout(u_char *buf, int len);
long SequenceHostToRtulong(long lValue);
int SequenceHostToRtuint(int iValue);
DWORD SequenceHostToRtuDWord(DWORD dwValue);
DWORD SequenceRtuToHostDWord(DWORD dwValue);
#endif // !defined(_BASEFUNC_H_200506101543__INCLUDED_)

85
basetype.h
Unescape Escape View File

@ -0,0 +1,85 @@
/****************************************************************************
* FileName : basetype.h *
* Programmer : Li Liangchu *
* Writen at : 2002.09.20 *
* Version : *
* Description: header of the nport.c *
* Last modify: 2002.11.6 *
****************************************************************************/
#ifndef __BASETYPE_H_ICL__
#define __BASETYPE_H_ICL__
/*#ifndef OS_WINDOWS
//#include <winsock.h>
//#else
#include <sys/types.h>
#else*/
typedef unsigned char u_char;
typedef unsigned short u_short;
typedef unsigned int u_int;
typedef unsigned long u_long;
//#endif// OS_WINDOWS
typedef u_char BYTE;
typedef u_short WORD;
typedef u_long DWORD;
typedef long i_32;
typedef u_long u_32;
typedef int BOOL;
#define TRUE 1
#define FALSE 0
typedef struct tagCMDDEF
{
u_32 CmdTimerCnt; //命令时间计数
u_32 CmdTimerConst; //命令时间间隔
} CMDDEF, *pCMDDEF;
/*#ifndef OS_WINDOWS
typedef int bool;
typedef int64_t _int64;
typedef uint64_t _uint64;
typedef u_long UINT;
#define true TRUE
#define false FALSE
typedef struct
{
WORD Year __attribute__ ((packed));
u_char Month __attribute__ ((packed));
u_char Day __attribute__ ((packed));
u_char WeekDay __attribute__ ((packed));
u_char MonthDay __attribute__ ((packed));
u_char Hour __attribute__ ((packed));
u_char Min __attribute__ ((packed));
u_char Sec __attribute__ ((packed));
u_char reserved __attribute__ ((packed));
WORD mSec __attribute__ ((packed));
}DAY_TIME;
#define DSLIB_API
#else*/
#ifdef DSLIB_EXPORTS
#define DSLIB_API __declspec(dllexport)
#else
#define DSLIB_API __declspec(dllimport)
#endif// DSLIB_EXPORTS
#pragma pack (push,1)
typedef struct
{
WORD Year;
u_char Month;
u_char Day;
u_char WeekDay;
u_char MonthDay;
u_char Hour;
u_char Min;
u_char Sec;
u_char reserved;
WORD mSec;
} DAY_TIME;
#pragma pack (pop)
//#endif// OS_WINDOWS
#endif// __BASETYPE_H_ICL__

13336
buban103.cpp
View File

File diff suppressed because it is too large Load Diff

2255
buban103.h
View File

File diff suppressed because it is too large Load Diff

4881
buban104.cpp
View File

File diff suppressed because it is too large Load Diff

291
buban104.h
Unescape Escape View File

@ -0,0 +1,291 @@
/************************************************************************************
*
* Copyright (C) 2004-2005 SCADA Control Technology Co., Ltd.
* All rights reserved.
*
* 文件名称：buban104.h
* 文件标识：部颁104规约
* 摘 要：104规约的处理的结构、宏还有函数定义
*
* 当前版本：1.0
* 作 者：aaawen
* 完成日期：2005/09/14
*
* 取代版本：1.0
* 原作者 ：
* 完成日期：
*
* 说 明：数据定义规则
* u8 --- BYTE(usigned char)
* ch --- char
* w --- WORD(u_short, usigned short)
* sh --- short
* b --- BOOL(bool)
* i --- int
* l --- long
* u32 --- u_32
* ui --- unsigned int(u_int)
* ul --- unsigned long(u_long)
* f --- float
* db --- double
* c --- class
* s --- struct
* sta --- static
* g --- 全局变量
* Array --- 数组
* a --- 数组
* m_ --- 数据成员
* p --- 指针
* str --- 字符串
* 全部大写 --- 常量
* 首字节必须大写--- 类名称，结构，函数
**************************************************************************************/
// buban104.h: interface for the buban104 class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(_BUBAN104_H_200509141152__INCLUDED_)
#define _BUBAN104_H_200509141152__INCLUDED_
#ifdef OS_LINUX
#include "baohulib/common.h"
#else
#include "common.h"
#endif
//////////////////////////////////////////////////////////////////////////
// 宏定义 //
// WEN 2005.09.08 //
//////////////////////////////////////////////////////////////////////////
#define MAX_104_PINUM 30
#define FORMAT_I 14 // I-格式
#define FORMAT_S 15 // S-格式
#define FORMAT_U_START_ACT 16 // U-格式启动
#define FORMAT_U_START_CON 17 // U-格式启动应答
#define FORMAT_U_STOP_ACT 18 // U-格式停止
#define FORMAT_U_STOP_CON 19 // U-格式停止应答
#define FORMAT_U_TEST_ACT 20 // U-格式测试
#define FORMAT_U_TEST_CON 21 // U-格式测试应答
// 定时召唤命令及命令名称
#define BUBAN104_TIMER_CMD_NUM 3 // 最大命令数目
#define MAX_SEQUENCE 0x7fff // 最大帧计数
#define MAX_FRAMEMATCHING_SIZE 2 // 帧序匹配最大尺寸
// 规约版本号
#define VER_BUBAN_104 0 // 部颁104
#define VER_IEC870_5_104 1 // IEC104
/////////////////////////////结构定义/////////////////////////////////
typedef struct
{
long CmdTimerCnt;
long CmdTimerConst;
} BUBAN104CMDDEF;
typedef struct tagBUBAN104PORTPARAM
{
BOOL LinkOk; // 主站初始化标志 1:ok; 0:no 初始化时：FALSE
BOOL Initdata; // 初始化总召唤标志 TRUE：收到总召唤结束帧
// FALSE：未收到总召唤结束帧
// 召唤电度标志 TRUE：收到召唤结束帧
// FALSE：未收到召唤结束帧
WORD wLinkAddr; // 地址域
WORD wSendSequence; // 发送帧计数
WORD wRecvSequence; // 接收帧计数
WORD wAckSequence; // 应答帧计数
BOOL bAckRight; // 应答帧是否同步 (子站端有效)
BOOL bStopComm; // 通讯停止
BOOL bSendFormatI;
BYTE ProvAckOrNot; // 转发是否要求应答
long lTimeOutSendTest;// 超时发送测试帧
long lTimeOutConst; // 超时时间间隔
long lTimeOutCnt; // 超时时间计数
long lYkYtAckTimeConst;// 返校超时时间间隔
long lYkYtAckTime; // 返校超时时间计数
BOOL bCloseSocket; // 关闭socket端口
char YkCmdBuf[32]; // 遥控延迟发送返校缓冲区
long lYkCmdBuflen; // 遥控延迟发送返校缓冲区数据长
long m_lNoDataCnt; // 无数据时间，超过超时时间发送测试帧
short RtuVersion; // 版本号
int m_iPublishYear; // 发布时间(缺省为2000版)
short CurCmdIdx;
short YkMode; // 遥控方式(=0：双点遥控，=1：单点遥控，=2：直控方式)
// wen 2005.01.15 修改数据信息体起始地址
int iAiBaseAddr; // 遥测起始地址
int iDiBaseAddr; // 遥信起始地址
int iPiBaseAddr; // 遥脉起始地址
int iYkBaseAddr; // 遥控起始地址
BYTE m_au8RecvBuf[300];
int m_iRecvLen;
int m_iFrameSize; // 帧序应答尺寸
BYTE m_bProvAiType; // 转发遥测类型标识
BUBAN104CMDDEF CmdTime[BUBAN104_TIMER_CMD_NUM];
SIO_PARAM_BAOHU_DEF *m_psBaoHu; // 该规约的端口数据指针
} BUBAN104PORTPARAM, *pBUBAN104PORTPARAM;
/////////////////////////以下为通用函数接口///////////////////////////
/*!
\brief 读取配置函数
\param commid -- 端口号
\note
取值范围：0 -- MaxSerialPortNum + MaxNetPortNum -1\n
*/
void Buban104ReadConfig(int commid); // 初始化处理
/*!
\brief 读取端口数据函数
\param commid -- 端口号
\note
取值范围：0 -- MaxSerialPortNum + MaxNetPortNum -1\n
\param buf -- 数据源缓冲区指针
\param len -- 数据源长度
*/
void Buban104RecvData(int commid, u_char *buf, int len);// 规约读数据处理
/*!
\brief 规约数据处理定时器函数
\param commid -- 端口号
\note
取值范围：0 -- MaxSerialPortNum + MaxNetPortNum -1\n
*/
void Buban104Timer(int commid); // 定时器处理
/*!
\brief 遥控遥调数据处理函数
\param commid -- 端口号
\note
取值范围：0 -- MaxSerialPortNum + MaxNetPortNum -1\n
\param buf -- 数据源缓冲区指针
\param len -- 数据源长度
*/
void Buban104YkYtProcess(int commid, u_char *buf, int len); // 遥控遥调处理
/*!
\brief 系统下发对时函数
\param commid -- 端口号
\note
取值范围：0 -- MaxSerialPortNum + MaxNetPortNum -1\n
*/
void Buban104SendSystemTime(int commid); // 系统对时
/*!
\brief 系统退出时规约处理函数
\param commid -- 端口号
\note
取值范围：0 -- MaxSerialPortNum + MaxNetPortNum -1\n
*/
void Buban104Exit(int commid); // 规约退出
/*!
\brief 保护命令处理函数
\param commid -- 端口号
\param rtumsg -- 下发的保护命令指针
\note
取值范围：0 -- MaxSerialPortNum + MaxNetPortNum -1\n
*/
void Buban104BaoHuCmdProcess(int commid, RTUMSG *rtumsg, BOOL bUpData);
/*!
\brief 取保护数据库指针函数
\param commid -- 端口号
\param iProvAddr -- 统一编排的保护转发地址
\param ppBaoHuDB -- 存放保护数据指针的指针
\retval -- 返回该装置保护数据组数
*/
int Buban104GetBaohuDataBase(int commid, int iProvAddr, GROUPDEF **ppBaoHuDB);
/////////////////////////通用函数接口结束///////////////////////////////
/////////////////////////buban104公共函数接口///////////////////////////
//指令缓冲区初始化
void InitBuban104CommandBuffer(int commid);
//关闭socket通讯
void Buban104CloseSocket(u_32 commid);
/////////////////////////buban104公共函数接口结束///////////////////////
/////////////////////////以下为通用函数支持接口/////////////////////////
void Buban104ProvMakeYkYtCommand(int commid, u_char *buf, int len);
/////////////////////////通用函数支持接口结束///////////////////////////
///////////////////////////以下为指令生成函数///////////////////////////
//生成 Buban104 命令?
void MakeBuban104Command(u_32 commid, u_char cmdidx);
//生成遥控遥调指令
void MakeBuBan104YkYtCommand(u_32 commid, u_char *buf, int len);
///////////////////////////指令生成函数结束/////////////////////////////
/////////////////////以下为POLLING规约常规函数接口//////////////////////
void Buban104FindNextCmd(int commid);
void Buban104FindNextProvCmd(int commid);
void Buban104SendCmdFormPollCmdBuf(int commid);
//////////////////////POLLING规约常规函数接口结束///////////////////////
///////////////////////以下为规约处理函数接口///////////////////////////
//======================以下为主站数据处理============================
void Buban104ProcessData(u_32 commid, BUBAN104PORTPARAM *psPortParam, BOOL bProcess);
//处理数据格式I
void Buban104FormatI(RTUMSG *rtumsg);
//处理数据格式U
void Buban104FormatU(RTUMSG *rtumsg);
//Buban104 初始化数据处理
void Buban104InitdataProecss(RTUMSG * rtumsg);
//电度结束帧
void Buban104PidataEnd(RTUMSG * rtumsg);
//设定确认
void Buban104SetAck(RTUMSG *rtumsg);
//Buban104 遥控遥调返校程序
void Buban104YkYtAck(RTUMSG * rtumsg);
//Buban104 对时程序
void Buban104SynTime(RTUMSG * rtumsg);
// 子站主动传送遥信变位帧
void Buban104AutoSendDiProcess(RTUMSG *rtumsg);
void Buban104AiWithPzDataProcess(RTUMSG *, int);
void Buban104AllAiDataProcess(RTUMSG *rtumsg);
void Buban104AllFloatAiDataProcess(RTUMSG *rtumsg);
void Buban104DiDataProcess(RTUMSG *rtumsg, int);
void Buban104SoeDataProcess(RTUMSG *rtumsg, int);
void Buban104PiDataProcess(RTUMSG * rtumsg);
void Buban104PiWithTimeDataProcess(RTUMSG *rtumsg);
//保护数据处理
void Buban104BaoHuDataProcess(RTUMSG *rtumsg);
void Buban104DefaultBaoHuDataProcess(RTUMSG *rtumsg);
// 新增函数，含有 7 BYTE 的时标
void Buban104SoeDataProcessWithCP56Time2a(RTUMSG *rtumsg, int flag);
void Buban104AiWithDataProcessWithM_ME_TD_1(RTUMSG * rtumsg);
void Buban104AiWithDataProcessWithM_ME_TE_1(RTUMSG * rtumsg);
void Buban104AiWithDataProcessWithM_ME_TF_1(RTUMSG * rtumsg);
void Buban104PiWithTimeDataProcessWithM_IT_TB_1(RTUMSG *rtumsg);
//======================以下为子站数据处理============================
void ProvBuban104dataProcess(int commid, RTUMSG *rtumsg);
void ProvBuban104FormatI(int commid, RTUMSG *rtumsg);
void ProvBuban104FormatU(int commid, RTUMSG *rtumsg);
void ProvBuban104FormatS(int commid, RTUMSG *rtumsg);
void ProvBuban104SendAllData(int commid, RTUMSG *rtumsg);
void ProvBuban104SendPIData(int commid, RTUMSG *rtumsg);
void ProvBuban104ProcessTime(int commid, RTUMSG *rtumsg);
//iGroupNo=0为响应总召唤
void ProvBuban104SendPI(int commid, RTUMSG *rtumsg, int iGroupNo);
void ProvBuban104SendAI(int commid, RTUMSG *rtumsg, int iGroupNo);
void ProvBuban104SendDI(int commid, RTUMSG *rtumsg, int iGroupNo);
void ProvBuban104SendSoe(int commid);
void ProvBuban104YkYtData(int commid, RTUMSG *rtumsg);
void MakeProvBuban104YkYtAckMsg(int commid, int pnt, int op, int step);
void ProvBuban104SendClass1(int commid);
void ProvBuban104SendClass2(int commid);
void ProvMakeBuban104Command(int commid, u_char cmdidx);
void ProvBuban104SendAIwithFloat(int commid, RTUMSG *rtumsg, int iGroupNo);
void ProvBuban104SendClass2withFloat(int commid);
/////////////////////////规约处理函数接口结束///////////////////////////
#endif // !defined(_BUBAN104_H_200509141152__INCLUDED_)

174
chainlist.cpp
Unescape Escape View File

@ -0,0 +1,174 @@
//***************************************************************
//* chainlist.cpp *
//* aaawen 2005.05.27 *
//***************************************************************
//#ifdef OS_WINDOWS
#include <stdio.h>
#include <process.h>
//#endif
#include <memory.h>
#include <stdlib.h>
#include "chainlist.h"
#include "basefunc.h"
#include "os_heap.h"
// SingleList
void SingleListInit(SINGLELIST *psSingleList, int iMaxNum)
{
psSingleList->iDevId = 0;
psSingleList->iMaxNum = iMaxNum;
psSingleList->iNum = 0;
psSingleList->pHead = NULL;
psSingleList->pTail = NULL;
}
void SingleListInitEx(SINGLELIST *psSingleList, int iMaxNum, int iDevId)
{
psSingleList->iDevId = iDevId;
psSingleList->iMaxNum = iMaxNum;
psSingleList->iNum = 0;
psSingleList->pHead = NULL;
psSingleList->pTail = NULL;
}
int SingleListHaveData(SINGLELIST *psSingleList)
{
return psSingleList->iNum;
}
BOOL SingleListAddData(SINGLELIST *psSingleList, BYTE *pu8Data, int iDataLen)
{
char szDbg[128];
SINGLELISTUNIT *pUnit;
if(psSingleList->iNum >= psSingleList->iMaxNum)
{
sprintf(szDbg, "WARN(%04d): DevId=%08x SingleListAddData is Overflow.\n",
_getpid(), psSingleList->iDevId);
DebugPrint(szDbg);
return FALSE;
}
pUnit = (SINGLELISTUNIT *)HEAP_MALLOC(sizeof(SINGLELISTUNIT));
if(pUnit == NULL)
{
sprintf(szDbg, "WARN(%04d): DevId=%08x SingleListAddData malloc(%d) is failed in unit.\n",
_getpid(), psSingleList->iDevId, sizeof(SINGLELISTUNIT));
DebugPrint(szDbg);
return FALSE;
}
pUnit->pNext = NULL;
pUnit->pBuf = (BYTE *)HEAP_MALLOC(iDataLen+1);
if(pUnit->pBuf == NULL)
{
HEAP_FREE(pUnit);
sprintf(szDbg, "WARN(%04d): DevId=%08x SingleListAddData malloc(%d) is failed in content.\n",
_getpid(), psSingleList->iDevId, iDataLen+1);
DebugPrint(szDbg);
return FALSE;
}
pUnit->iLen = iDataLen;
memcpy(pUnit->pBuf, pu8Data, iDataLen);
if(psSingleList->pTail == NULL)
{
psSingleList->pTail = pUnit;
}
else
{
psSingleList->pTail->pNext = pUnit;
psSingleList->pTail = pUnit;
}
if(psSingleList->pHead == NULL)
{
psSingleList->pHead = pUnit;
}
psSingleList->iNum++;
return TRUE;
}
int SingleListGetAndDelData(SINGLELIST *psSingleList, BYTE *pu8Data, int iMaxLen)
{
int iDataLen;
SINGLELISTUNIT *pUnit;
if(psSingleList->pHead == NULL)
{
return 0;
}
pUnit = psSingleList->pHead;
psSingleList->iNum--;
if(psSingleList->iNum <= 0)
{
psSingleList->iNum = 0;
psSingleList->pHead = NULL;
psSingleList->pTail = NULL;
}
else
{
psSingleList->pHead = pUnit->pNext;
}
if(pUnit->iLen > iMaxLen)
{
iDataLen = iMaxLen;
}
else
{
iDataLen = pUnit->iLen;
}
memcpy(pu8Data, pUnit->pBuf, iDataLen);
HEAP_FREE(pUnit->pBuf);
HEAP_FREE(pUnit);
return iDataLen;
}
BOOL SingleListDelData(SINGLELIST *psSingleList)
{
SINGLELISTUNIT *pUnit;
if(psSingleList->pHead == NULL)
{
return FALSE;
}
pUnit = psSingleList->pHead;
psSingleList->iNum--;
if(psSingleList->iNum <= 0)
{
psSingleList->iNum = 0;
psSingleList->pHead = NULL;
psSingleList->pTail = NULL;
}
else
{
psSingleList->pHead = pUnit->pNext;
}
HEAP_FREE(pUnit->pBuf);
HEAP_FREE(pUnit);
return TRUE;
}
BOOL SingleListDelAllData(SINGLELIST *psSingleList)
{
while(1)
{
if(SingleListDelData(psSingleList) == FALSE)
{
break;
}
}
return TRUE;
}

49
chainlist.h
Unescape Escape View File

@ -0,0 +1,49 @@
//////////////////////////////////////////////////////////////////////
#if !defined(_CHAINLIST_H_AAAWEN_200505271056__INCLUDED_)
#define _CHAINLIST_H_AAAWEN_200505271056__INCLUDED_
#include "basetype.h"
// 单向链表
typedef struct tagSINGLELISTUNIT
{
int iLen; // 数据长度
BYTE *pBuf; // 存储内容
struct tagSINGLELISTUNIT *pNext; // 单项链表的下一个
}SINGLELISTUNIT;
typedef struct tagSINGLELIST
{
int iDevId; // 端口号(高2个字节为端口号, 低2个字节为装置号)
int iNum;
int iMaxNum;
SINGLELISTUNIT *pHead;
SINGLELISTUNIT *pTail;
}SINGLELIST;
typedef struct tagDOUBLELISTUNIT
{
int iDataLen; // 数据长度
BYTE *pDataBuf; // 存储内容
struct tagDOUBLELISTUNIT *pNext; // 双向链表的下一个
struct tagDOUBLELISTUNIT *pFore; // 双向链表的前一个
}DOUBLELISTUNIT;
typedef struct tagDOUBLELIST
{
int iNum;
int iMaxNum;
DOUBLELISTUNIT *pHead;
DOUBLELISTUNIT *pTail;
}DOUBLELIST;
// SingleList
DSLIB_API void SingleListInit(SINGLELIST *psSingleList, int iMaxNum);
DSLIB_API void SingleListInitEx(SINGLELIST *psSingleList, int iMaxNum, int iDevId);
DSLIB_API int SingleListHaveData(SINGLELIST *psSingleList);
DSLIB_API BOOL SingleListAddData(SINGLELIST *psSingleList, BYTE *pu8Data, int iDataLen);
DSLIB_API int SingleListGetAndDelData(SINGLELIST *psSingleList, BYTE *pu8Data, int iMaxLen);
DSLIB_API BOOL SingleListDelData(SINGLELIST *psSingleList);
DSLIB_API BOOL SingleListDelAllData(SINGLELIST *psSingleList);
#endif // !defined(_CHAINLIST_H_AAAWEN_200505271056__INCLUDED_)

1221
common.h
View File

File diff suppressed because it is too large Load Diff

4286
commport.cpp
View File

File diff suppressed because it is too large Load Diff

134
commport.h
Unescape Escape View File

@ -0,0 +1,134 @@
#ifndef __COMM_PORT_H_ICL__
#define __COMM_PORT_H_ICL__
#include "common.h"
#define MSGTYPE_BAOHU_BASE 200
#define MSGTYPE_BAOHU_103CMD MSGTYPE_BAOHU_BASE+0
#define MSGTYPE_BAOHU_103DATA MSGTYPE_BAOHU_BASE+1
#define MSGTYPE_BAOHU_SCADACMD MSGTYPE_BAOHU_BASE+2
#define MSGTYPE_BAOHU_SCADADATA MSGTYPE_BAOHU_BASE+3
// 从 config.ini 或 portconfig.ini 读信息
u_long GetPrivateProString(const char *section, const char *entry, const char *defaultstr, char *result, int len, char *inifile);
int GetPrivateProInt(const char *section, const char *entry, int idefault, char *inifile);
u_long GetPrivateProString2(const char *section, const char *entry, const char *defaultstr, char *result, int len, HDSFILE hFile);
int GetPrivateProInt2(const char *section, const char *entry, int idefault, HDSFILE hFile);
int PutDataToBuf( DATA_BUF *buf, u_char *msg, int len );
int GetDataFormBuf( DATA_BUF *databuf, u_char *buf, int len, int clrflag );
// 读设备信息，检查芯片状态和读芯片类型和频率
void ReadPortConfigInfo( u_short );
void ReadPortConfigInfoEx(u_short);
void OpenAllPort( void );
void CloseOnePort( int commid );
void CloseAllPort( void );
void PollAllSerialPort( void );
void PollAllNetPort( void );
int SetPntMsg( int port, int point, void *pntmsg, BYTE type, BYTE attr );
int GetPntMsg( int port, int point, void *pntmsg, BYTE type, BYTE attr );
int SetPorvPntMsg( int port, int point, void *pntmsg, BYTE type, BYTE attr );
int GetPorvPntMsg( int port, int point, void *pntmsg, BYTE type );
int CheckPollCmdBufEmpty( int port );
int PutPollCmdToBuf( int port, int type, WORD wait, char *buf, int len );
void SendCmdFormPollCmdBuf( int port );
// wen 2005.09.08 清空指令缓冲区中的所有指令
void ClearAllCmdFromPollCmdBuf(int port);
// wen 2004.10.25 公布函数接口
void ClearCmdFormPollCmdBuf( int port );
void ClearCmdFormPollCmdBufEx( int port, char *file, int line );
void ClearCmdAllFlag( int port );
int GetCmdFormPollCmdBuf( int port, u_char *buf, int len );
int ReGetCmdFormPollCmdBuf( int port, u_char *buf, int len );
int GetMaxPort();
int GetPortProtocolIdx(char *name);
char *GetPortProtocolName(int Idx);
// wen 2004.11.16 增加转发soe数据的处理
// 返回缓冲区中的soe数据数量
int ProvWriteSoeData( int provport, SOE_DEF *ptrSoe );
int ProvAndDelGetSoeData( int provport, SOE_DEF *ptrSoe );
int ProvHaveSoeData( int provport );
// wen 2005.02.23
void SendDataToPort(int commid, char *buf, int len);
// wen 2005.02.28
void SendYkYtCommand(int commid, char *buf, int len);
BOOL SendYkYtCommand2(int commid, YKYT_PARAM *pParam);
int FindProvPntFromYkYtPnt(int commid, int ykytpnt, SIO_PARAM_BAOHU_DEF *pBaohuParam);
BOOL ProvPortYkYtIsTimeOut( int commid, PROV_YKYT_DEF *pProvYkYt );
BOOL IsProvYkYtAck(int commid, PROV_YKYT_DEF *pProvYkYt);
BOOL ShmGetDispYkYtFlag();
BOOL ShmGetDispHostLinkFlag();
// wen 2005.04.18 内存的分配与释放
void PortMemoryMalloc( int commid, int type, SIO_PARAM_BAOHU_DEF *pBaohuParam );
void PortMemoryMallocEx( int commid, int type, SIO_PARAM_BAOHU_DEF *pBaohuParam );
BOOL PortDataPntInit(int commid, int type, SIO_PARAM_BAOHU_DEF *pBaohuParam);
void PortMemoryFree( int commid, SIO_PARAM_DEF *pGenParam );
void PortWriteDataFree( int commid );
BOOL IsBaoHuPtr( int commid );
BOOL IsExtInfoPtr( int commid );
BOOL IsSerialPtr( int commid );
/*!
\brief 获取端口打开标识
\param commid -- 端口号
\param rwflag -- 读标识还是写标识
\返回值 retval-- 返回端口读或者写状态
*/
int ShmGetPortFlag(int commid, int rwflag);
// 保护数据处理
/*!
\brief 发送保护数据到实际的装置
\param commid -- 端口号
\param rtumsg -- 转发的保护指令
\note
指令格式暂时用部颁103规约格式
*/
void SendProtectCmdToDev(int commid, RTUMSG *rtumsg);
/*!
\brief 将实际装置数据保存到指令下发端口
\param rtumsg -- 转发的保护指令
\note
指令格式暂时用部颁103规约格式
*/
void PutBaohuDataToPort(RTUMSG *rtumsg);
void PutBaohuDataToPortEx(int commid, RTUMSG *rtumsg);
/*!
\brief 将数据发送到所有的scadaprotect规约端口
\param rtumsg -- 转发的保护指令
*/
void SendDataToAllScadaProtectPort(RTUMSG *rtumsg);
/*!
\brief 获取指定装置的保护数据库
\param commid -- 端口号
\param iProvAddr -- 保护装置转发地址，端口统一编排的地址
\param ppBaoHuDB -- 存储保护装置保护数据的指针(PAI,PDI,PFIX...)
\retval 返回该装置保护数据组数
*/
int GetBaohuDB(int commid, int iProvAddr, GROUPDEF **ppBaoHuDB);
int GetSioParam(SIO_PARAM_DEF **ppParam);
int GetDevParam(DEV_DEF **ppParam);
int SetCurPort(int PortNo);
int GetCurPortEx();
int SetDispFlag(int iFlag);
// 获取全局变量
SIO_PARAM_DEF *GetSioParamPtr();
#endif

42
conf_close.cpp
Unescape Escape View File

@ -0,0 +1,42 @@
//#include <util/util.h>
#include <stdlib.h>
#include <malloc.h>
#include "confrw_errno.h"
//#include "confrw.h"
#include "_confrw.h"
#include "Profile_Hash.h"
/*
* 关闭配置文件句柄
*
* 参数
* handle -- 配置文件句柄
*
* 返回值
* SUCCESS -- 成功的关闭了指定的配置文件句柄(包括资源释放等工作)
* 其它 -- 失败代码
*
* 备注
* 如果输入的参数非配置文件(上下文)句柄, 则不作任何事.
*
*/
int conf_close ( void * handle )
{
int ret = SUCCESS;
if ( NULL == handle )
return NULL;
ret = close_profile_handle ( (HPROFILE )*(int *)handle );
if ( SUCCESS != ret )
return ret;
free ( handle );
return SUCCESS;
}

47
conf_open.cpp
Unescape Escape View File

@ -0,0 +1,47 @@
//#include <util/util.h>
#include <stdlib.h>
#include <malloc.h>
#include "confrw_errno.h"
#include "confrw.h"
#include "_confrw.h"
#include "Profile_Hash.h"
/*
* 打开配置文件, 返回表示配置文件的句柄
*
* 参数
* pszfname -- 配置文件的全路径名(默认为 char [MAX_PATH]类型)
* ppvhandle -- 在函数执行成功的情况下, 返回配置文件(的上下文环境)句柄
*
* 返回值
* SUCCESS -- 成功的执行了该函数, 并打开了给定的配置文件
* 其它 -- 失败代码
*
*/
int conf_open ( const char * pszfname, void ** ppvhandle )
{
int ret = SUCCESS;
if ( NULL == pszfname || NULL == ppvhandle )
return ERROR_POINTER;
int handle = -1;
ret = create_profile_cache ( (char *)pszfname, &handle );
if ( SUCCESS != ret )
{
*ppvhandle = NULL;
return ret;
}
else
{
*ppvhandle = calloc ( 1, sizeof(long) );
*((int *)*ppvhandle) = handle;
return SUCCESS;
}
}

111
conf_read_key.cpp
Unescape Escape View File

@ -0,0 +1,111 @@
/********************************************************************************
*
* Copyright (C) 1999-2000 SCADA Technology Control Co., Ltd. All rights reserved.
*
* 读配置文件的调用接口函数 之
* 根据指定的 [段]及键的名称, 获取配置文件中的配置项
*
* 创建日期: 2002/01/21
*
*
*
* $Name: $
*
* $Revision: 1.2 $
*
* $Date: 2006/08/04 03:37:33 $
*
* $State: Exp $
*
* $Log: conf_read_key.cpp,v $
* Revision 1.2 2006/08/04 03:37:33 zhuzhenhua
* no message
*
* Revision 1.1.2.1 2006/07/28 07:54:02 zhuzhenhua
* no message
*
* Revision 1.2 2003/01/02 03:14:51 scada
* trim substitution line
*
* Revision 1.1.1.1 2002/08/21 07:16:39 harold
* temporarily import
*
* Revision 1.8 2002/03/20 03:40:22 harold
* no message
*
* Revision 1.1.1.1 2002/03/15 13:43:21 harold
* no message
*
* Revision 1.1.1.1 2002/03/15 08:17:11 harold
* no message
*
* Revision 1.7 2002/01/23 06:07:22 harold
* no message
*
* Revision 1.6 2002/01/23 05:43:55 harold
* no message
*
* Revision 1.5 2002/01/23 05:41:06 harold
* no message
*
* Revision 1.4 2002/01/23 03:35:41 harold
* no message
*
* Revision 1.3 2002/01/23 03:34:24 harold
* no message
*
* Revision 1.2 2002/01/23 03:26:24 harold
* no message
*
* Revision 1.1 2002/01/21 02:46:53 harold
* no message
*
*
*
********************************************************************************/
//#include <util/util.h>
#include "confrw_errno.h"
#include "confrw.h"
#include "_confrw.h"
#include "Profile_Hash.h"
/*
* 根据指定的 [段]及键的名称, 获取配置文件中的配置项
*
* 参数
* handle -- 配置文件句柄
* pszsec_name -- 段名
* pszkey_name -- 键名称
* pszdefault -- 键的默认值, 以null字符结尾的字符串,
* 如果配置文件中没有该键的配置, 同时, 该参数不为空, 则返回该值
* pbuf -- 返回值的缓冲区
* buffer_length -- 缓冲区长度
*
* 返回值
* SUCCESS -- 成功的执行了本函数
* 其它 -- 失败代码
*
*/
int conf_read_key ( void * handle,
const char * pszsec_name,
const char * pszkey_name,
const char * pszdefault,
char * pbuf,
int buffer_length )
{
int len = buffer_length;
return get_pgcprofile_string ( (char *)pszsec_name,
(char *)pszkey_name,
(char *)pszdefault,
pbuf,
(pgcu32 *)&len,
(HPROFILE)*(int *)handle );
}

96
conf_write_key.cpp
Unescape Escape View File

@ -0,0 +1,96 @@
/********************************************************************************
*
* Copyright (C) 1999-2000 SCADA Technology Control Co., Ltd. All rights reserved.
*
* 读配置文件的调用接口函数 之
* 修改/添加一个新的配置项
*
* 创建日期: 2002/01/21
*
*
*
* $Name: $
*
* $Revision: 1.2 $
*
* $Date: 2006/08/04 03:37:33 $
*
* $State: Exp $
*
* $Log: conf_write_key.cpp,v $
* Revision 1.2 2006/08/04 03:37:33 zhuzhenhua
* no message
*
* Revision 1.1.2.1 2006/07/28 07:54:02 zhuzhenhua
* no message
*
* Revision 1.2 2003/01/02 03:14:51 scada
* trim substitution line
*
* Revision 1.1.1.1 2002/08/21 07:16:39 harold
* temporarily import
*
* Revision 1.5 2002/03/20 03:40:22 harold
* no message
*
* Revision 1.1.1.1 2002/03/15 13:43:21 harold
* no message
*
* Revision 1.1.1.1 2002/03/15 08:17:11 harold
* no message
*
* Revision 1.4 2002/01/23 05:41:06 harold
* no message
*
* Revision 1.3 2002/01/23 03:35:41 harold
* no message
*
* Revision 1.2 2002/01/23 03:26:24 harold
* no message
*
* Revision 1.1 2002/01/21 02:46:53 harold
* no message
*
*
*
********************************************************************************/
//#include <util/util.h>
#include "confrw_errno.h"
#include "confrw.h"
#include "_confrw.h"
#include "typedef.h"
#include "Profile_Hash.h"
/*
* 修改/添加一个新的配置项
*
* 参数
* handle -- 配置文件句柄
* pszsec_name -- 段名
* pszkey_name -- 键名
* pszkey_value -- 键的值
* force_insert -- 如果(段, 键)不存在, 是否需要插入该(段, 键)的配置值,
* 如果该参数等于0, 则不插入该配置项, 否则, 插入该配置项.
*
* 返回值
* SUCCESS -- 成功
* 其它 -- 失败代码
*
*/
int conf_write_key ( void * handle,
const char * pszsec_name,
const char * pszkey_name,
const char * pszkey_value,
int force_insert )
{
return write_pgcprofile_string ( pszsec_name,
pszkey_name,
pszkey_value,
force_insert ? PGCTRUE : PGCFALSE,
(HPROFILE)*(int *)handle );
}

44
config.ini
Unescape Escape View File

@ -0,0 +1,44 @@
[网络设置]
主机网络端口=7119
PING接收端口=13124
PING发送端口=13123
[主机地址]
主机A地址1=192.168.1.199
停止向主机发送端口全数据=0
[前置机]
前置机A地址1=192.168.1.143
前置机A地址2=192.168.2.143
前置机B地址1=192.168.1.113
前置机B地址2=192.168.2.113
前置机A地址1掩码=255.255.255.0
前置机A地址2掩码=255.255.255.0
前置机B地址1掩码=255.255.255.0
前置机B地址2掩码=255.255.255.0
允许前置机连接=1
前置机连接=2
起始厂站号=0
运行方式=0
主备切换端口屏蔽字=0x00000000
[对时]
对时方式=1
[NetCommPort]
UdpCommPort=0xfe00
TcpCommPort=0xff01
WatchCommPort=0xff02
[PortConfig]
Port1=1
Port2=1
Port3=1
Port4=1
Port5=1
Port6=1
Port7=1
Port8=1
Port9=1
Port10=1
Port11=1
Port12=1
Port13=1
Port14=1
Port15=1
Port16=1

177
confrw.h
Unescape Escape View File

@ -0,0 +1,177 @@
#if !defined(__CONFRW_H__QWERUOIPUADFJHAFKLHADSFHADSFVCMBVZXCVQOEWIRADSHJKXZJVBLWQERYO)
#define __CONFRW_H__QWERUOIPUADFJHAFKLHADSFHADSFVCMBVZXCVQOEWIRADSHJKXZJVBLWQERYO
/*!
* \if developer_doc
* \file
*
* \brief 读配置文件的调用接口头文件,包括:系统限值常量, 外部接口函数声明头文件。
*
* id: $Id: confrw.h,v 1.2 2006/08/04 03:37:33 zhuzhenhua Exp $
*
* \author 杨小波 prcharold@sina.com.cn develop1@szscada.com
* \endif
*/
//#include <util/util.h>
#include "confrw_errno.h"
#ifdef OS_LINUX
#define DSLIB_API
#else
#ifdef CONFRWLIB_EXPORTS
#define CONFRWLIB_API __declspec(dllexport)
#else
#define CONFRWLIB_API __declspec(dllimport)
#endif// CONFRWLIB_EXPORTS
#endif//OS_LINUX
/*!
* \if by_group
* \addtogroup grp_config_rw
* @{
* \endif
*/
/*!
* \brief 打开配置文件, 返回表示配置文件的句柄
*
* \param pszfname --[in] 配置文件的全路径名(默认为 char [MAX_PATH]类型)
* \param ppvhandle --[in] 在函数执行成功的情况下, 返回配置文件(的上下文环境)句柄
*
* \retval 返回值
* \retval SUCCESS -- 成功的执行了该函数, 并打开了给定的配置文件
* \retval 其它 -- 失败代码
*
*/
CONFRWLIB_API int conf_open ( const char * pszfname, void ** ppvhandle );
/*!
* \brief 关闭配置文件句柄
*
* \param handle --[in] 配置文件句柄
*
* \retval SUCCESS -- 成功的关闭了指定的配置文件句柄(包括资源释放等工作)
* \retval ERROR_CONF_HANLDE -- 错误的配置文件读写句柄
* \retval 其它 -- 失败代码
*
* \note
* 如果输入的参数非配置文件(上下文)句柄, 则不作任何事.
*
*/
CONFRWLIB_API int conf_close ( void * handle );
/*!
* \brief 根据指定的 [段]及键的名称, 获取配置文件中的配置项
*
* \param handle --[in] 配置文件句柄
* \param pszsec_name --[in] 段名, 以null字符结尾的字符串
* \param pszkey_name --[in] 键名称, 以null字符结尾的字符串
* \param pszdefault --[in] 键的默认值, 以null字符结尾的字符串,如果配置文件中没有该键的配置, 同时, 该参数不为空, 则返回该值
* \param pbuf --[out] 返回值的缓冲区
* \param buffer_length --[in] 缓冲区长度
*
* \retval SUCCESS -- 配置的键值存在, 且成功地读出
* \retval 如果给出默认值, 则在欲读取的键值/键不存在地情况下, 同样返回SUCCESS
* \retval ERROR_CONF_SECTION -- 欲读取的键所在的段不存在
* \retval ERROR_CONF_KEY -- 欲读取的键不存在
* \retval 其它 -- 失败代码
*/
CONFRWLIB_API int conf_read_key ( void * handle,
const char * pszsec_name,
const char * pszkey_name,
const char * pszdefault,
char * pbuf,
int buffer_length );
/*!
* \brief 修改/添加一个新的配置项
*
* \param handle --[in] 配置文件句柄
* \param pszsec_name --[in] 段名
* \param pszkey_name --[in] 键名
* \param pszkey_value --[in] 键的值
* \param force_insert --[in] 如果(段, 键)不存在, 是否需要插入该(段, 键)的配置值,
* 如果该参数等于0, 则不插入该配置项, 否则, 插入该配置项.
*
* \retval SUCCESS -- 成功
* \retval 其它 -- 失败代码
*
* \note
* 如果 force_insert 为0, 则当配置文件中不存在指定段时, 返回 ERROR_CONF_SECTION;
* 如果不存在指定(段/键)组合时, 返回 ERROR_CONF_KEY.
*/
CONFRWLIB_API int conf_write_key ( void * handle,
const char * pszsec_name,
const char * pszkey_name,
const char * pszkey_value,
int force_insert );
/*!
* \brief 从配置文件中删除一个指定的配置项(段, 键)
*
* \param handle --[in] 配置文件句柄
* \param pszsec_name --[in] 段名
* \param pszkey_name --[in] 键名
*
* \retval SUCCESS -- 成功的删除了指定的配置项
* \retval 其它 -- 失败代码
*
* \note
* 如果指定的段不存在, 则返回 ERROR_CONF_SECTION
* 如果指定(段, 键名称)组合不存在, 则返回 ERROR_CONF_KEY
*/
CONFRWLIB_API int conf_delete_key ( void * handle,
const char * pszsec_name,
const char * pszkey_name );
/*!
* \brief 删除配置文件中一个整段的配置
*
* \param handle --[in] 配置文件句柄
* \param pszsec_name --[in] 希望删除的段的名称, 以null字符结尾的字符串
*
* \retval SUCCESS -- 成功的删除了配置文件中的指定的段
* \retval 其它 -- 失败代码
*
* \note
* 如果指定的段不存在, 则返回 ERROR_CONF_SECTION
*/
CONFRWLIB_API int conf_delete_section ( void * handle,
const char * pszsec_name );
/*!
* \if by_group
* @}
* \endif
*/
#endif //!defined(__CONFRW_H__QWERUOIPUADFJHAFKLHADSFHADSFVCMBVZXCVQOEWIRADSHJKXZJVBLWQERYO)

69
confrw_errno.h
Unescape Escape View File

@ -0,0 +1,69 @@
#if !defined(__CONFRW_ERRNO_H__OPQEWUIPADSJKHZXCXZVNZCADLHJFOQEWPOQYUEHJASDFHPWQEUQ)
#define __CONFRW_ERRNO_H__OPQEWUIPADSJKHZXCXZVNZCADLHJFOQEWPOQYUEHJASDFHPWQEUQ
/*!
* \if developer_doc
* \file
*
* \brief 读配置文件的调用接口函数库的错误代码定义头文件。
*
* id: $Id: confrw_errno.h,v 1.2 2006/08/04 03:37:33 zhuzhenhua Exp $
*
* \author 杨小波 prcharold@sina.com.cn develop1@szscada.com
* \endif
*/
#include "global_errno.h"
/*!
* \if by_group
* \addtogroup grp_config_rw
* @{
* \endif
*/
//!< 不能为当前打开的配置文件缓冲分配一个句柄，原因是句柄已经全被占用
#define ERROR_CONF_NOHANDLE (ERROR_CONF_BASE + 1)
//!< 创建哈希表失败
#define ERROR_CONF_CREATEHASH (ERROR_CONF_BASE + 2)
//!< 输入了非法的配置文件缓冲句柄
#define ERROR_CONF_INVALIDHANDLE (ERROR_CONF_BASE + 3)
//!< 在读配置文件时，用户开辟的接收缓冲区不够大
#define ERROR_CONF_REVBUFFER (ERROR_CONF_BASE + 4)
//!< 在读配置文件时，因指定的段的项目名不存在，函数执行缺省拷贝，并返回此结果
#define SUCCESS_CONF_DEFCOPY (ERROR_CONF_BASE + 5)
//!< 不能输入一个空的句柄指针作参数
#define ERROR_CONF_NULL_HANDEPTR (ERROR_CONF_BASE + 6)
//!< 输入的段名，项目名，项目值的字符串长度超长
#define ERROR_CONF_INPUTSTRING_TOOLARGE (ERROR_CONF_BASE + 7)
//!< 指定的段或项目并不存在
#define ERROR_CONF_NOTEXIST (ERROR_CONF_BASE + 8)
/*!
*\verbatim
以下为confrw_ex中定义的错误代码
*\endvervatim
*/
//!< 无效的配置文件句柄
#define ERROR_CONF_HANDLE (ERROR_CONF_BASE + 9)
//!< 指定的段不存在
#define ERROR_CONF_SECTION (ERROR_CONF_BASE + 10)
//!< 指定的键值不存在
#define ERROR_CONF_KEY (ERROR_CONF_BASE + 11)
/*!
* \if by_group
* @}
* \endif
*/
#endif //!defined(__CONFRW_ERRNO_H__OPQEWUIPADSJKHZXCXZVNZCADLHJFOQEWPOQYUEHJASDFHPWQEUQ)

625
display.cpp
Unescape Escape View File

@ -0,0 +1,625 @@
//#include "stdafx.h"
#include "display.h"
#include "commport.h"
extern SIO_PARAM_DEF SioParam[];
extern int iCurDevIdx;
extern DEV_DEF DevParam[];
HWND hMainWnd;
int RealDataDispFlag;
int CurPort;
int DispType = 0;
int ListIndex = 0; // 显示序号索引起始
int ItemNumOfPage; // 页显示项目数
COLORREF dwColorVal[16] = // 显示颜色定义
{
RGB(255,255,255), RGB(128,128,128),
RGB(255, 0, 0), RGB(255,255, 0),
RGB( 0,255, 0), RGB( 0,255,255),
RGB( 0, 0,255), RGB(255, 0,255),
RGB(192,192,192), RGB( 0, 0, 0),
RGB(128, 0, 0), RGB(128,128, 0),
RGB( 0,128, 0), RGB( 0,128,128),
RGB( 0, 0,128), RGB(128, 0,128)
};
void RealAiDataDisp( HDC hdc )
{
UINT xWd, yHg, lineh, tmp;
int i, j, total, idx, itemofline;
char szbuf[256];
RECT rc;
AI_DEF *aiptr;
float sp;
int pos[6];
GetClientRect( hMainWnd, &rc );
itemofline = 2;
CaculateWH( hdc, &xWd, &yHg, (char*)"行距" );
lineh = yHg + 5;
rc.top = 10;
SetTextColor( hdc, dwColorVal[BLUE] );
// 显示标题
sprintf( szbuf,"端口%02d 实时遥测数据信息", CurPort + 1 );
DrawText(hdc, (CONST WCHAR*)szbuf, strlen(szbuf), &rc, DT_CENTER );
rc.top += (lineh + 5);
SetTextColor( hdc, dwColorVal[BLACK] );
// 计算显示位置
pos[0] = 0;
pos[3] = rc.right / 2;
tmp = 0;
CaculateWH( hdc, &xWd, &yHg, (char*)"序号" );
tmp += xWd;
pos[1] = pos[0] + xWd;
pos[4] = pos[3] + xWd;
CaculateWH( hdc, &xWd, &yHg, (char*)"测点名称" );
tmp += xWd;
pos[2] = pos[1] + xWd;
pos[5] = pos[4] + xWd;
CaculateWH( hdc, &xWd, &yHg, (char*)"测点原值" );
tmp += xWd;
sp = ((float)rc.right - (float)tmp*itemofline) / (itemofline*4);
pos[0] += (int)sp;
pos[1] += (int)(sp*2);
pos[2] += (int)(sp*3);
pos[3] += (int)(sp);
pos[4] += (int)(sp*2);
pos[5] += (int)(sp*3);
// 显示项目名称
for ( i = 0; i < itemofline; i++ )
{
sprintf( szbuf, (char*)"序号" );
rc.left = pos[i*3];
DrawText( hdc, (CONST WCHAR*)szbuf, strlen(szbuf), &rc, DT_LEFT );
sprintf( szbuf, (char*)"测点名称" );
rc.left = pos[i*3+1];
DrawText( hdc, (CONST WCHAR*)szbuf, strlen(szbuf), &rc, DT_LEFT );
sprintf( szbuf, (char*)"测点原值" );
rc.left = pos[i*3+2];
DrawText( hdc, (CONST WCHAR*)szbuf, strlen(szbuf), &rc, DT_LEFT );
}
rc.top += lineh;
ItemNumOfPage = (rc.bottom - rc.top) / lineh;
if( !IsBaoHuPtr(CurPort) )
return;
// 计算总行数
total = (SioParam[CurPort].m_psBaoHu->AiNum + itemofline - 1) / itemofline;
// 调整显示的起始位置
if ( total < ItemNumOfPage )
ListIndex = 0;
if ( (ListIndex + ItemNumOfPage) > total )
ListIndex = total - ItemNumOfPage;
if ( ListIndex < 0 )
ListIndex = 0;
// 显示输出
idx = ListIndex * itemofline;
aiptr = (AI_DEF*)SioParam[CurPort].m_psBaoHu->AiPtr;
if( !aiptr )
return;
for ( i = 0; (i < ItemNumOfPage) && (idx < SioParam[CurPort].m_psBaoHu->AiNum); i++ )
{
for ( j = 0; j < itemofline; j++ )
{
if((idx + j) >= SioParam[CurPort].m_psBaoHu->AiNum)
break;
sprintf( szbuf, "%03d", idx + j + 1 );
rc.left = pos[j*3+0];
CaculateWH( hdc, &xWd, &yHg, (char*)"序号" );
rc.right = rc.left + xWd;
DrawText( hdc, (CONST WCHAR*)szbuf, strlen(szbuf), &rc, DT_CENTER );
sprintf( szbuf, "遥测%03d", idx + j + 1 );
rc.left = pos[j*3+1];
CaculateWH( hdc, &xWd, &yHg, (char*)"测点名称" );
rc.right = rc.left + xWd;
DrawText( hdc, (CONST WCHAR*)szbuf, strlen(szbuf), &rc, DT_CENTER );
sprintf( szbuf, "0x%04x", aiptr[idx+j].RawValue & 0xffff );
rc.left = pos[j*3+2];
CaculateWH( hdc, &xWd, &yHg, (char*)"测点原值" );
rc.right = rc.left + xWd;
DrawText( hdc, (CONST WCHAR*)szbuf, strlen(szbuf), &rc, DT_CENTER );
}
idx += itemofline;
rc.top += lineh;
}
}
void RealDiDataDisp( HDC hdc )
{
UINT xWd, yHg, lineh, tmp;
int i, j, total, idx, itemofline;
char szbuf[256], stchar = 1;
RECT rc;
DI_DEF *diptr;
float sp;
int pos[6];
GetClientRect( hMainWnd, &rc );
CaculateWH( hdc, &xWd, &yHg, (char*)"行距" );
lineh = yHg + 5;
itemofline = 2;
rc.top = 10;
SetTextColor( hdc, dwColorVal[BLUE] );
// 显示标题
sprintf( szbuf,"端口%02d 实时遥信数据信息", CurPort + 1 );
DrawText(hdc, (CONST WCHAR*)szbuf, strlen(szbuf), &rc, DT_CENTER );
rc.top += (lineh + 5);
SetTextColor( hdc, dwColorVal[BLACK] );
// 计算显示位置
pos[0] = 0;
pos[3] = rc.right / 2;
tmp = 0;
CaculateWH( hdc, &xWd, &yHg, (char*)"序号" );
tmp += xWd;
pos[1] = pos[0] + xWd;
pos[4] = pos[3] + xWd;
CaculateWH( hdc, &xWd, &yHg, (char*)"测点名称" );
tmp += xWd;
pos[2] = pos[1] + xWd;
pos[5] = pos[4] + xWd;
CaculateWH( hdc, &xWd, &yHg, (char*)"状态" );
tmp += xWd;
sp = ((float)rc.right - (float)tmp*itemofline) / (itemofline*4);
pos[0] += (int)sp;
pos[1] += (int)(sp*2);
pos[2] += (int)(sp*3);
pos[3] += (int)(sp);
pos[4] += (int)(sp*2);
pos[5] += (int)(sp*3);
// 显示项目名称
for ( i = 0; i < itemofline; i++ )
{
sprintf( szbuf, (char*)"序号" );
rc.left = pos[i*3+0];
DrawText( hdc, (CONST WCHAR*)szbuf, strlen(szbuf), &rc, DT_LEFT );
sprintf( szbuf, (char*)"测点名称" );
rc.left = pos[i*3+1];
DrawText( hdc, (CONST WCHAR*)szbuf, strlen(szbuf), &rc, DT_LEFT );
sprintf( szbuf, (char*)"状态" );
rc.left = pos[i*3+2];
DrawText( hdc, (CONST WCHAR*)szbuf, strlen(szbuf), &rc, DT_LEFT );
}
rc.top += lineh;
ItemNumOfPage = (rc.bottom - rc.top) / lineh;
if( !IsBaoHuPtr(CurPort) )
return;
// 计算总行数
total = (SioParam[CurPort].m_psBaoHu->DiNum + itemofline - 1) / itemofline;
// 调整显示的起始位置
if ( total < ItemNumOfPage )
ListIndex = 0;
if ( (ListIndex + ItemNumOfPage) > total )
ListIndex = total - ItemNumOfPage;
if ( ListIndex < 0 )
ListIndex = 0;
// 显示输出
idx = ListIndex * itemofline;
diptr = (DI_DEF*)SioParam[CurPort].m_psBaoHu->DiPtr;
if( !diptr )
return;
for ( i = 0; (i < ItemNumOfPage) && (idx < SioParam[CurPort].m_psBaoHu->DiNum); i++ )
{
for ( j = 0; j < itemofline; j++ )
{
if((idx + j) >= SioParam[CurPort].m_psBaoHu->DiNum)
break;
sprintf( szbuf, "%03d", idx + j + 1 );
rc.left = pos[j*3+0];
CaculateWH( hdc, &xWd, &yHg, (char*)"序号" );
rc.right = rc.left + xWd;
DrawText( hdc, (CONST WCHAR*)szbuf, strlen(szbuf), &rc, DT_CENTER );
sprintf( szbuf, "遥信%03d", idx + j + 1 );
rc.left = pos[j*3+1];
CaculateWH( hdc, &xWd, &yHg, (char*)"测点名称" );
rc.right = rc.left + xWd;
DrawText( hdc, (CONST WCHAR*)szbuf, strlen(szbuf), &rc, DT_CENTER );
sprintf( szbuf, "%s", diptr[idx+j].Status ? (char*)"合" : (char*)"分" );
rc.left = pos[j*3+2];
CaculateWH( hdc, &xWd, &yHg, (char*)"状态" );
rc.right = rc.left + xWd;
DrawText( hdc, (CONST WCHAR*)szbuf, strlen(szbuf), &rc, DT_CENTER );
}
idx += itemofline;
rc.top += lineh;
}
}
void RealPiDataDisp( HDC hdc )
{
UINT xWd, yHg, lineh, tmp;
int i, j, total, idx, itemofline;
char szbuf[256];
RECT rc;
PI_DEF *piptr;
float sp;
int pos[6];
GetClientRect( hMainWnd, &rc );
itemofline = 2;
CaculateWH( hdc, &xWd, &yHg, (char*)"行距" );
lineh = yHg + 5;
rc.top = 10;
SetTextColor( hdc, dwColorVal[BLUE] );
// 显示标题
sprintf( szbuf,"端口%02d 实时电度数据信息", CurPort + 1 );
DrawText(hdc, (CONST WCHAR*)szbuf, strlen(szbuf), &rc, DT_CENTER );
rc.top += (lineh + 5);
SetTextColor( hdc, dwColorVal[BLACK] );
// 计算显示位置
pos[0] = 0;
pos[3] = rc.right / 2;
tmp = 0;
CaculateWH( hdc, &xWd, &yHg, (char*)"序号" );
tmp += xWd;
pos[1] = pos[0] + xWd;
pos[4] = pos[3] + xWd;
CaculateWH( hdc, &xWd, &yHg, (char*)"测点名称" );
tmp += xWd;
pos[2] = pos[1] + xWd;
pos[5] = pos[4] + xWd;
CaculateWH( hdc, &xWd, &yHg, (char*)"测点原值" );
tmp += xWd;
sp = ((float)rc.right - (float)tmp*itemofline) / (itemofline*4);
pos[0] += (int)sp;
pos[1] += (int)(sp*2);
pos[2] += (int)(sp*3);
pos[3] += (int)(sp);
pos[4] += (int)(sp*2);
pos[5] += (int)(sp*3);
// 显示项目名称
for ( i = 0; i < itemofline; i++ )
{
sprintf( szbuf, (char*)"序号" );
rc.left = pos[i*3+0];
DrawText( hdc, (CONST WCHAR*)szbuf, strlen(szbuf), &rc, DT_LEFT );
sprintf( szbuf, (char*)"测点名称" );
rc.left = pos[i*3+1];
DrawText( hdc, (CONST WCHAR*)szbuf, strlen(szbuf), &rc, DT_LEFT );
sprintf( szbuf, (char*)"测点原值" );
rc.left = pos[i*3+2];
DrawText( hdc, (CONST WCHAR*)szbuf, strlen(szbuf), &rc, DT_LEFT );
}
rc.top += lineh;
ItemNumOfPage = (rc.bottom - rc.top) / lineh;
if( !IsBaoHuPtr(CurPort) )
return;
// 计算总行数
total = (SioParam[CurPort].m_psBaoHu->PiNum + itemofline - 1) / itemofline;
// 调整显示的起始位置
if ( total < ItemNumOfPage )
ListIndex = 0;
if ( (ListIndex + ItemNumOfPage) > total )
ListIndex = total - ItemNumOfPage;
if ( ListIndex < 0 )
ListIndex = 0;
// 显示输出
idx = ListIndex * itemofline;
piptr = (PI_DEF*)SioParam[CurPort].m_psBaoHu->PiPtr;
if( !piptr )
return;
for ( i = 0; (i < ItemNumOfPage) && (idx < SioParam[CurPort].m_psBaoHu->PiNum); i++ )
{
for ( j = 0; j < itemofline; j++ )
{
if((idx + j) >= SioParam[CurPort].m_psBaoHu->PiNum)
break;
sprintf( szbuf, "%03d", idx + j + 1 );
rc.left = pos[j*3+0];
CaculateWH( hdc, &xWd, &yHg, (char*)"序号" );
rc.right = rc.left + xWd;
DrawText( hdc, (CONST WCHAR*)szbuf, strlen(szbuf), &rc, DT_CENTER );
sprintf( szbuf, "电度%03d", idx + j + 1);
rc.left = pos[j*3+1];
CaculateWH( hdc, &xWd, &yHg, (char*)"测点名称" );
rc.right = rc.left + xWd;
DrawText( hdc, (CONST WCHAR*)szbuf, strlen(szbuf), &rc, DT_CENTER );
sprintf( szbuf, "0x%08x", piptr[idx+j].RawValue );
rc.left = pos[j*3+2];
CaculateWH( hdc, &xWd, &yHg, (char*)"测点原值" );
// wen 2004.11.19 显示的长度是名称的1.5倍
//rc.right = rc.left + xWd;
//DrawText( hdc, szbuf, strlen(szbuf), &rc, DT_CENTER );
rc.right = rc.left + xWd/4*6;
DrawText( hdc, (CONST WCHAR*)szbuf, strlen(szbuf), &rc, DT_LEFT );
}
idx += itemofline;
rc.top += lineh;
}
}
void WatchDataDisp( HDC hdc )
{
UINT xWd, yHg, lineh;
int i, j, total, idx, type;
char szbuf[256];
RECT rc;
GetClientRect( hMainWnd, &rc );
CaculateWH( hdc, &xWd, &yHg, (char*)"行距" );
lineh = yHg + 5;
rc.top = 10;
if ( DevParam[iCurDevIdx].WatchDispLine.LineCnt == 0 )
{
sprintf( szbuf, "当前没有数据....." );
DrawText(hdc, (CONST WCHAR*)szbuf, strlen(szbuf), &rc, DT_LEFT );
return;
}
ItemNumOfPage = (rc.bottom - rc.top) / lineh;
total = DevParam[iCurDevIdx].WatchDispLine.LineCnt;
if ( RealDataDispFlag )
ListIndex = 100000;
// 调整显示的起始位置
if ( total < ItemNumOfPage )
ListIndex = 0;
if ( (ListIndex + ItemNumOfPage) > total )
ListIndex = total - ItemNumOfPage;
if ( ListIndex < 0 )
ListIndex = 0;
// 寻找数据起始位置
idx = DevParam[iCurDevIdx].WatchDispLine.Rear - total;
if ( idx < 0 )
idx += MAX_DISP_LINE;
// 显示起始位置
idx += ListIndex;
for ( i = 0; i < min(ItemNumOfPage, total); i++ )
{
j = (idx + i) % MAX_DISP_LINE;
type = DevParam[iCurDevIdx].WatchDispLine.Line[j][0];
if ( type == 'R' ) // 接收数据
SetTextColor( hdc, dwColorVal[BLUE] );
else
SetTextColor( hdc, dwColorVal[MAGENTA] );
strcpy( szbuf, (char*)&DevParam[iCurDevIdx].WatchDispLine.Line[j][1] );
DrawText( hdc, (CONST WCHAR*)szbuf, strlen(szbuf), &rc, DT_LEFT );
rc.top += lineh;
}
}
//***************************************************************
//* 新字体函数? *
//***************************************************************
HFONT NewFont( int nFSize )
{
/*
WCHAR typeface[32] = (WCHAR *)"宋体";
LOGFONT LogFont = { 0, 0, 0, 0,
400,
0,
0,
0,
DEFAULT_CHARSET,
//OUT_STROKE_PRECIS,
OUT_STRING_PRECIS,
CLIP_DEFAULT_PRECIS,
PROOF_QUALITY,
DEFAULT_PITCH,
typeface
//"新宋体"
//"黑体"
//"隶书"
//"幼圆"
//"仿宋_GB2312"
};
LogFont.lfWidth = (LONG)((float)nFSize*.618);
LogFont.lfHeight = (LONG)nFSize;
strcpy( LogFont.lfFaceName, "Lee宋体" );
return( CreateFontIndirect( &LogFont ));*/
return NULL;
}
void DataDisp( HWND hWnd )
{
HDC hdc;
HFONT hFont;
int nFSize;
hdc = GetDC( hWnd );
if( WATCH_DATA_DISP != DispType)
nFSize = 16;
else
nFSize = 12;
hFont = (HFONT)SelectObject( hdc, NewFont( nFSize ) );
if( !IsBaoHuPtr(CurPort) )
return;
switch( DispType )
{
case AI_DATA_DISP:
if(PROV_PROTOCOL != SioParam[CurPort].m_psBaoHu->PortType)
RealAiDataDisp( hdc );
break;
case DI_DATA_DISP:
if(PROV_PROTOCOL != SioParam[CurPort].m_psBaoHu->PortType)
RealDiDataDisp( hdc );
break;
case PI_DATA_DISP:
if(PROV_PROTOCOL != SioParam[CurPort].m_psBaoHu->PortType)
RealPiDataDisp( hdc );
break;
case WATCH_DATA_DISP:
WatchDataDisp( hdc );
break;
}
DeleteObject( SelectObject(hdc, hFont) );
ReleaseDC( hWnd, hdc );
}
//***************************************************************
//* 计算字串显示宽度和高度 *
//***************************************************************
void CaculateWH( HDC hdc, UINT *xWidth, UINT *yHeight, char *szStr )
{
RECT rc;
DrawText( hdc, (CONST WCHAR*)szStr, strlen(szStr), &rc, DT_CALCRECT );
*xWidth = rc.right - rc.left;
*yHeight = rc.bottom - rc.top;
}
//****************************************************************
//* 显示数据上页? *
//****************************************************************
void PageUp( void )
{
ListIndex -= ItemNumOfPage;
if ( ListIndex < 0 )
ListIndex = 0;
}
//***************************************************************
//* 显示数据下页? *
//***************************************************************
void PageDown( void )
{
ListIndex += ItemNumOfPage;
}
//***************************************************************
//* 显示端口最后一页数据 *
//***************************************************************
void PageEnd( void )
{
ListIndex = 100000;
}
//***************************************************************
//* 显示端口最前一页数据? *
//***************************************************************
void PageHome( void )
{
ListIndex = 0;
}
void LineUp( void )
{
ListIndex--;
if ( ListIndex < 0 )
ListIndex = 0;
}
//***************************************************************
//* 显示下移一行? *
//***************************************************************
void LineDown( void )
{
ListIndex++;
}
int GetCurPort()
{
return CurPort;
}
int IsRealDataDisp()
{
return RealDataDispFlag;
}

55
display.h
Unescape Escape View File

@ -0,0 +1,55 @@
#include "common.h"
#ifndef __DISPLAY_H_ICL__
#define __DISPLAY_H_ICL__
#define WHITE 0
#define DARKGRAY 1
#define RED 2
#define YELLOW 3
#define GREEN 4
#define CYAN 5
#define BLUE 6
#define MAGENTA 7
#define GRAY 8
#define BLACK 9
#define BROWN 10
#define DYELLOW 11
#define DGREEN 12
#define DCYAN 13
#define DBLUE 14
#define DMAGENTA 15
#define AI_DATA_DISP 4
#define DI_DATA_DISP 5
#define PI_DATA_DISP 6
#define WATCH_DATA_DISP 8
void RealAiDataDisp( HDC hdc );
void RealDiDataDisp( HDC hdc );
void RealPiDataDisp( HDC hdc );
void RealStatInfoDisp( HDC hdc );
void WatchDataDisp( HDC hdc );
int CheckDev( HDC hdc );
void DataDisp( HWND hWnd );
HFONT NewFont( int nFSize );
void CaculateWH( HDC hdc, UINT *xWidth, UINT *yHeight, char *szStr );
void PageUp( void );
void PageDown( void );
void PageHome( void );
void PageEnd( void );
void LineUp( void );
void LineDown( void );
// wen 2004.10.25
int GetCurPort();
int IsRealDataDisp();
#endif

11
filelist.txt
Unescape Escape View File

@ -0,0 +1,11 @@
portconfig.ini
config.ini
inf/scada.csv
inf/port103ser.csv
inf/port103sie.csv
inf/top9xxx_h.csv
dat/top9xxx_h.dat
dat/103-RCS925A.dat
dat/103-7SJ682.dat
dat/mach300.dat
inf/mach300.csv

803
global_errno.h
Unescape Escape View File

@ -0,0 +1,803 @@
/*****************************************************************************
*
* Copyright (C) 1999-2000 SCADA Technology Control Co., Ltd. All rights reserved.
*
* 2001/11/3
*
* 全局性的共同性的错误代码宏定义, 以"ERROR_"开头
* 公共的错误代码从1开始到0xffff结束.
*
*
*
* $Name: $
*
* $Revision: 1.2 $
*
* $Date: 2006/08/04 03:37:33 $
*
* $State: Exp $
*
* $Log: global_errno.h,v $
* Revision 1.2 2006/08/04 03:37:33 zhuzhenhua
* no message
*
* Revision 1.12 2003/09/17 15:00:37 scada
* 添加错误代码: ERROR_MKDIR/ERROR_OPEN/ERROR_EXIST
*
* Revision 1.11 2003/08/01 06:38:01 scada
* 定义在Windows操作系统上没有定义的, 但是SYSV(unix)系统上定义了的操作代码的基值
*
* Revision 1.10 2003/06/05 03:56:15 jehu
* 将注释修改为符合doxgen工具提取开发文档
*
* Revision 1.9 2003/01/15 10:25:41 scada
* update thread dead lock
*
* Revision 1.8 2003/01/02 03:14:29 scada
* trim substitution line
*
* Revision 1.7 2002/12/06 01:05:04 scada
* for NT
*
* Revision 1.6 2002/12/04 07:47:36 scada
* for NT
*
* Revision 1.5 2002/10/24 09:07:33 scada
* avoid conflict between ERROR_AUTHSERV_BASE and ERROR_RTDBM_BASE
*
* Revision 1.4 2002/10/10 07:31:27 jehu
* *** empty log message ***
*
* Revision 1.3 2002/10/09 13:01:29 harold
* add errno base macro ERROR_RTDBM_BASE
*
* Revision 1.2 2002/09/18 09:13:38 harold
* revised errors and warning under solaris/CC environment
*
* Revision 1.1.1.1 2002/08/21 07:16:36 harold
* temporarily import
*
* Revision 1.23 2002/07/26 13:07:55 scada
* 为写文件fputs调用失败添加一个全局错误代码=>ERROR_FPUTS
*
* Revision 1.22 2002/07/23 06:59:04 scada
* 使所有模块的错误代码的低16bit不等于0, 以免和进程返回成功码(低8bit)冲突
*
* Revision 1.21 2002/07/12 10:01:47 harold
* add module errno base: ERROR_MISRELAY_BASE
*
* Revision 1.20 2002/06/03 08:47:05 harold
* add tracable module librmtcalc and rmtcalc
*
* Revision 1.19 2002/05/14 06:53:02 harold
* add ERROR_DBRW_BASE for dbrw module
*
* Revision 1.18 2002/04/12 08:58:38 harold
* global_errno.h
*
* Revision 1.17 2002/04/12 01:01:32 harold
* add ERROR_RECV and ERROR_TIMEOUT
*
* Revision 1.16 2002/04/09 13:19:36 harold
* *** empty log message ***
*
* Revision 1.15 2002/04/05 07:27:59 harold
* add error code ERROR_EXECV, ERROR_PTHREAD_CREATE
*
* Revision 1.14 2002/04/03 06:59:18 harold
* add EXP_STRCASECMP and EXP_STRNCASECMP for compare two string ignoring case
*
* Revision 1.13 2002/04/02 15:54:48 harold
* revise unkown linux-g++ compile error by copying the older tru64-cxx version
*
* Revision 1.12 2002/03/29 00:56:27 harold
* *** empty log message ***
*
* Revision 1.11 2002/03/20 03:39:56 harold
* no message
*
* Revision 1.2 2002/03/17 15:33:51 harold
* changed for iccp v0.9
*
* Revision 1.1.1.1 2002/03/15 13:43:17 harold
* no message
*
* Revision 1.2 2002/03/15 13:10:03 harold
* *** empty log message ***
*
* Revision 1.1.1.1 2002/03/15 08:17:07 harold
* no message
*
* Revision 1.11 2002/03/11 11:02:53 harold
* *** empty log message ***
*
* Revision 1.10 2002/03/05 07:41:18 harold
* *** empty log message ***
*
* Revision 1.9 2002/03/05 03:01:34 harold
* *** empty log message ***
*
* Revision 1.8 2002/02/28 00:53:17 harold
* *** empty log message ***
*
* Revision 1.7 2002/02/27 13:04:29 harold
* no message
*
* Revision 1.6 2002/02/25 07:30:21 harold
* no message
*
* Revision 1.5 2002/01/25 09:11:19 harold
* no message
*
* Revision 1.4 2002/01/22 08:55:06 harold
* modify2002-01-22-16:46
*
* Revision 1.3 2002/01/21 13:44:51 harold
* no message
*
* Revision 1.2 2002/01/18 10:01:39 harold
* 添加"读取配置文件函数库"错误代码基值定义
*
* Revision 1.1.1.1 2001/12/24 09:33:23 harold
* no message
*
* Revision 1.2 2001/12/24 06:39:57 harold
* 为了适应不同的操作系统, 不同的CPU类型, 及不同的编译器,
* 对头文件做了相应的修改, 同时添加了一些宏定义, 如:
* HAVE__FUNCTION__, __OS__, __PLATFORM__,__TIMEZONE__等等.
*
*
*****************************************************************************/
#ifndef __GLOBAL_ERROR_H__ADSFQEWRUPOHJCVLKJZHCVLKBAFLQWHPHFJJWTHNALSJFPQWJPH
#define __GLOBAL_ERROR_H__ADSFQEWRUPOHJCVLKJZHCVLKBAFLQWHPHFJJWTHNALSJFPQWJPH
/*!
* \if developer_doc
* \file
*
* \brief 全局性的共同性的错误代码宏定义, 以"ERROR_"开头,公共的错误代码从1开始到0xffff结束.
*
* id: $Id: global_errno.h,v 1.2 2006/08/04 03:37:33 zhuzhenhua Exp $
*
* \author 杨小波 prcharold@sina.com.cn develop1@szscada.com
* \endif
*/
/*!
* 函数执行成功
*/
#define SUCCESS 0
#ifndef OS_WINDOWS
# ifndef ERROR_SUCCESS
# define ERROR_SUCCESS (SUCCESS)
# endif //end of ERROR_SUCCESS
#endif // end of defined(__unix)
/*!
* 非错误性质的函数调用返回, 比如寻找缓冲区未找到等
*/
#define ERROR_FAIL 1
/*!
* 致命错误, 应该重新启动进程
*/
#define ERROR_FATAL 2
/*!
* 警告信息
*/
#define ERROR_WARNING 3
/*!
* 一些提示信息
*/
#define ERROR_TIPINFO 4
/*!
* 功能未实现
*/
#define ERROR_NOT_IMPLEMENT 5
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// 下面定义了各种库或者可执行模块中的错误代码基值
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
/*!
* 公共错误码的基础值
*/
#define ERROR_BASE 10
/*!
* 定义在Windows操作系统上没有定义的, 但是SYSV(unix)系统上定义了的操作代码的基值
* 要求常规的错误代码不能超过0xfff
*/
//#ifndef __unix
//# define ERROR_SYSV_BASE (ERROR_BASE + 0xfff)
//# include <sysv_errno.h>
//#endif
/*!
* 实时数据库模块中的错误代码的基础值
*/
#define ERROR_RTDB_BASE (0x10001)
/*!
* 历史库模块中的错误代码基础值
*/
#define ERROR_HDB_BASE (0x20001)
/*!
* 调试记录模块中的错误代码基础值
*/
#define ERROR_DBG_BASE (0x30001)
/*!
* 与Windows及旧Windows工作站软件上的日期时间兼容的日期时间处理库
* 中的错误代码基础值
*/
#define ERROR_XTIME_BASE (0x40001)
/*!
* 网络通信模块中的错误代码基础值
*/
#define ERROR_NET_BASE (0x50001)
/*!
* 网络写库函数模块错误代码基值
*/
#define ERROR_NET_WRITER_BASE (0x60001)
/*!
* DATASERV服务进程模块中的错误代码基值
*/
#define ERROR_DATASERV_BASE (0x70001)
/*!
* 配置文件读写库模块中的错误代码基值
*/
#define ERROR_CONF_BASE (0x80001)
/*!
* 事故追忆模块中的错误代码基值
*/
#define ERROR_PDR_BASE (0x90001)
/*!
* 软件跟踪模块中的错误代码基值
*/
#define ERROR_TRACE_BASE (0xA0001)
/*!
* 时间服务模块错误代码基值
*/
#define ERROR_TMSERV_BASE (0xB0001)
/*!
* 报警库错误代码基值
*/
#define ERROR_ALM_BASE (0xC0001)
/*!
* ICCP模块错误代码基值
*/
#define ERROR_ICCP_BASE (0xD0001)
/*!
* telectrl模块的错误代码基值
*/
#define ERROR_TELECTRL_BASE (0xE0001)
/*!
* dbrw模块的错误代码基值
*/
#define ERROR_DBRW_BASE (0xF0001)
/*!
* 计算模块(libcal, cal, librmtcalc, rmtcalc)中的错误代码基值
*/
#define ERROR_CALC_BASE (0x100001)
/*!
* Misserver中继服务模块中错误代码基值
*/
#define ERROR_MISRELAY_BASE (0x110001)
/*!
* AUTHSERV服务进程模块中的错误代码基值
*/
#define ERROR_AUTHSERV_BASE (0x120001)
/*!
* rtdbm之模块dbstudio/rtattr_s中的错误处理代码定义
*/
#define ERROR_RTDBM_BASE (0x130001)
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// 下面定义了最基本的错误代码, 则整个系统中公用
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
/*!
* 不可预料的错误
*/
#define ERROR_UNEXPECTED (ERROR_BASE + 1)
/*!
* 代码在执行过程中, 发生异常, 没有明确指明发生了何种异常
*/
#define ERROR_EXCEPTION (ERROR_BASE + 2)
/*!
* 代码在执行过程中, 发生访问冲突异常
*/
#define ERROR_EXCEPTION_ACCESS_VIOLATION (ERROR_BASE + 3)
/*!
* 给函数传递的参数错误, 如缓冲区长度不合理(非期望的长度),
* 又如, 序号值没有在给定的范围内等等.
*/
#define ERROR_PARAMETER (ERROR_BASE + 4)
/*!
* 在期望正确的指针参数时, 发现真正的指针参数为NULL
*/
#define ERROR_POINTER (ERROR_BASE + 5)
/*!
* 内存分配不成功
*/
#define ERROR_MEMORY_ALLOC (ERROR_BASE + 6)
/*!
* 找不到指定的环境变量
*/
#define ERROR_ENVIRONMENT_VARIABLE (ERROR_BASE + 7)
/*!
* 指定键值的IPC对象不存在, 即还未创建.
*/
#define ERROR_IPC_OBJECT_EXISTED (ERROR_BASE + 8)
/*!
* 打开文件调用fopen失败
*/
#define ERROR_FOPEN (ERROR_BASE + 9)
/*!
* 对文件内容调用fread失败.
*/
#define ERROR_FREAD (ERROR_BASE + 10)
/*!
* 映射共享内存到进程地址空间失败(shmat)
*/
#define ERROR_SHMAT (ERROR_BASE + 11)
/*!
* 取出进程空间中对共享内存的映射失败(shmdt)
*/
#define ERROR_SHMDT (ERROR_BASE + 13)
/*!
* 信号量操作失败(semctl)
*/
#define ERROR_SEMCTL (ERROR_BASE + 14)
/*!
* 系统没有足够的内存.
*/
#define ERROR_NO_MEMORY (ERROR_BASE + 15)
/*!
* 原始字节流队列已满
*/
#define ERROR_RAW_STREAM_QUEUE_IS_FULL (ERROR_BASE + 16)
/*!
* 原始字节流队列已删除
*/
#define ERROR_RAW_STREAM_QUEUE_IS_DELETE (ERROR_BASE + 17)
/*!
* 原始字节流队列中没有足够的数据
*/
#define ERROR_RAW_STREAM_QUEUE_NOT_ENOUGH_BYTE (ERROR_BASE + 18)
/*!
* 动态连接库装载失败(dlopen)
*/
#define ERROR_SHLIB_DLOPEN (ERROR_BASE + 19)
/*!
* 调用msgctl删除消息队列失败
*/
#define ERROR_MSGCTL_RMID (ERROR_BASE + 20)
/*!
* 调用msgget创建消息队列ipc对象失败
*/
#define ERROR_MSGGET_CREATE (ERROR_BASE + 21)
/*!
* 无效的消息队列ipc对象的id
*/
#define ERROR_MSG_QUEUE_ID (ERROR_BASE + 22)
/*!
* 从消息队列接收消息发生不可预料的错误
*/
#define ERROR_MSGRCV (ERROR_BASE + 23)
/*!
* 消息队列中当前被接收的消息超过给定的缓冲区
*/
#define ERROR_MSGRCV_TOO_BIG_ITEM (ERROR_BASE + 24)
/*!
* 欲操作的消息队列已经被删除(不存在, 需要重新创建)
*/
#define ERROR_MSG_QUEUE_REMOVED (ERROR_BASE + 25)
/*!
* 消息队列中没有消息
*/
#define ERROR_MSGRCV_NO_MSG (ERROR_BASE + 26)
/*!
* 调用msgget引用消息队列失败.
*/
#define ERROR_MSGGET_REFER (ERROR_BASE + 27)
/*!
* 调用SHMCTL获取共享内存属性失败
*/
#define ERROR_SHMCTL_STAT (ERROR_BASE + 28)
/*!
* 用于共享内存的挂接进程数目不为零而不能删除它.
*/
#define ERROR_DELETE_ATTACHED_SHM (ERROR_BASE + 29)
/*!
* 调用shmctl删除共享内存失败
*/
#define ERROR_SHMCTL_RMID (ERROR_BASE + 30)
/*!
* 调用shmctl锁定共享内存失败
*/
#define ERROR_SHMCTL_LOCK (ERROR_BASE + 31)
/*!
* 调用shmctl解除共享内存锁定失败
*/
#define ERROR_SHMCTL_UNLOCK (ERROR_BASE + 32)
/*!
* 调用semctl删除信号量组失败
*/
#define ERROR_SEMCTL_RMID (ERROR_BASE + 33)
/*!
* 调用shmget引用给定键值的共享内存区域失败
*/
#define ERROR_SHMGET_REFER (ERROR_BASE + 34)
/*!
* 调用shmget创建给定键值的共享内存区域失败
*/
#define ERROR_SHMGET_CREATE (ERROR_BASE + 35)
/*!
* 无效的进程内共享内存映射地址
*/
#define ERROR_SHM_ADDR_INVALID (ERROR_BASE + 36)
/*!
* 调用semop函数失败
*/
#define ERROR_SEMOP (ERROR_BASE + 37)
/*!
* 不存在指定的文件
*/
#define ERROR_NO_FILE (ERROR_BASE + 38)
/*!
* 调用stat取文件属性失败
*/
#define ERROR_STAT (ERROR_BASE + 39)
/*!
* 调用shmget失败, 创建一个新的信号量组失败
*/
#define ERROR_SEMGET_CREATE (ERROR_BASE + 40)
/*!
* 调用shmget失败, 创建一个新的信号量组失败
*/
#define ERROR_SEMGET_REFER (ERROR_BASE + 41)
/*!
* 调用fwrite失败
*/
#define ERROR_FWRITE (ERROR_BASE + 42)
/*!
* 参数中指定的缓冲区长度不够
*/
#define ERROR_BUFFER_LENGTH (ERROR_BASE + 43)
/*!
* 无效的属性号
*/
#define ERROR_ATTR_NO (ERROR_BASE + 44)
/*!
* 错误的SCADA日期时间串(这里仅指示日期时间串的格式错误, 不表明
* 其包含的日期时间值的正确与否
*/
#define ERROR_SCADA_DT_STRING (ERROR_BASE + 45)
/*!
* 缓冲区中的参数不完整(非自洽)
*/
#define ERROR_BUFFER_INTEGRALITY (ERROR_BASE + 46)
/*!
* 调用gethostname函数失败
*/
#define ERROR_GETHOSTNAME (ERROR_BASE + 47)
/*!
* 调用gethostbyname函数失败
*/
#define ERROR_GETHOSTBYNAME (ERROR_BASE + 48)
/*!
* 调用sendto非阻塞型失败
*/
#define ERROR_SENDTO (ERROR_BASE + 49)
/*!
* 接收到的消息的长度与与其预期的长度不等.
*/
#define ERROR_MSG_UNEXPECTED_LENGTH (ERROR_BASE + 50)
/*!
* 接收到的消息的类型与预期的不相同.
*/
#define ERROR_MSG_UNEXPECTED_TYPE (ERROR_BASE + 51)
/*!
* 调用socket创建套接字失败
*/
#define ERROR_SOCKET (ERROR_BASE + 52)
/*!
* 调用bind绑定套接字失败
*/
#define ERROR_BIND (ERROR_BASE + 53)
/*!
* 调用fcntl失败
*/
#define ERROR_FCNTL (ERROR_BASE + 54)
/*!
* 调用setsockopt失败
*/
#define ERROR_SETSOCKOPT (ERROR_BASE + 55)
/*!
* 调用getsockopt失败
*/
#define ERROR_GETSOCKOPT (ERROR_BASE + 56)
/*!
* 调用connect建立网络连接失败
*/
#define ERROR_CONNECT (ERROR_BASE + 57)
/*!
* 调用read意外失败
*/
#define ERROR_READ (ERROR_BASE + 58)
/*!
* 调用write意外失败
*/
#define ERROR_WRITE (ERROR_BASE + 59)
/*!
* 调用select函数意外失败
*/
#define ERROR_SELECT (ERROR_BASE + 60)
/*!
* 调用listen函数失败
*/
#define ERROR_LISTEN (ERROR_BASE + 61)
/*!
* 执行fork调用失败
*/
#define ERROR_FORK (ERROR_BASE + 62)
/*!
* 执行execve调用失败
*/
#define ERROR_EXECVE (ERROR_BASE + 63)
/*!
* 执行execv调用失败
*/
#define ERROR_EXECV (ERROR_BASE + 64)
/*!
* 创建线程失败pthread_create调用失败
*/
#define ERROR_PTHREAD_CREATE (ERROR_BASE + 65)
#define ERROR_CREATE_THREAD ERROR_PTHREAD_CREATE
/*!
* 调用recv接收套接字上的数据失败
*/
#define ERROR_RECV (ERROR_BASE + 66)
/*!
* 因为超时而失败
*/
#if defined(OS_LINUX)
#ifndef ERROR_TIMEOUT
#define ERROR_TIMEOUT (ERROR_BASE + 67)
#endif //end of ERROR_TIMEOUT
#endif // end of defined(__unix)
/*!
* 调用send失败
*/
#define ERROR_SEND (ERROR_BASE + 68)
/*!
* 调用select后, 发现异常fdset集合中异常事件.
*/
#define ERROR_SELECT_EXCEPTION (ERROR_BASE + 69)
/*!
* 当select探测到读事件, 但是随后读操作中仅读到0个字节
*/
#define ERROR_READ_ZERO (ERROR_BASE + 70)
/*!
* 当select探测到写事件, 但是随后写操作中仅写入0个字节
*/
#define ERROR_WRITE_ZERO (ERROR_BASE + 71)
/*!
* 当select探测接收事件, 但是随后接收操作中仅接收到0个字节
*/
#define ERROR_RECV_ZERO (ERROR_BASE + 72)
/*!
* 当select探测可以发送事件, 但是随后发送操作中仅发送了0个字节
*/
#define ERROR_SEND_ZERO (ERROR_BASE + 73)
/*!
* 不存在指定的目标
*/
#define ERROR_NOT_EXIST (ERROR_BASE + 74)
/*!
* 事务操作提交失败
*/
#define ERROR_COMMIT (ERROR_BASE + 75)
/*!
* 事务操作撤销/回滚失败
*/
#define ERROR_ROLLBACK (ERROR_BASE + 76)
/*!
* 调用fputs写文件失败
*/
#define ERROR_FPUTS (ERROR_BASE + 77)
/*!
* 调用mkdir失败
*/
#define ERROR_MKDIR (ERROR_BASE + 78)
/*!
* 调用OPEN失败
*/
#define ERROR_OPEN (ERROR_BASE + 79)
/*!
* 指定目标已经存在
*/
#define ERROR_EXIST (ERROR_BASE + 80)
/*!
* 调用fseek失败
*/
#define ERROR_FSEEK (ERROR_BASE + 81)
/*!
* 调用rename/MoveFile/MoveFileEx失败
*/
#define ERROR_RENAME (ERROR_BASE + 82)
/*!
* 无需运行cpfile.exe（当cpfile.exe在主服务器上时，返回本错误）
*/
#define ERROR_RUN_CPFILE_TCP_C_ON_PRAMIRY_HOST (ERROR_BASE + 83)
/*!
* 从消息队列中接收到无效的实时/历史数据请求数据帧类型
*/
#define ERROR_AUTHSERV_UNKNOWN_NET_FRAME (ERROR_AUTHSERV_BASE + 1)
#endif //__GLOBAL_ERROR_H__ADSFQEWRUPOHJCVLKJZHCVLKBAFLQWHPHFJJWTHNALSJFPQWJPH

1021
harximoban.h
View File

File diff suppressed because it is too large Load Diff

56
inifile.h
Unescape Escape View File

@ -0,0 +1,56 @@
/*----------------------------------------------------------
平台无关的INI文件读写函数 V1.65
张磊 2002.10.3
----------------------------------------------------------*/
#ifndef INI_FILE_H
#define INI_FILE_H
#include "platform_def.h"
#define MAX_LINE_BUF_LENGTH 2048 //最大行缓冲区长度
#define FILE_OPEN_ERROR -1 //文件打开错误
#define SECTION_NOT_FOUND -2 //段没有找到
#define KEY_NOT_FOUND -3 //键没有找到
//工具函数
void StrTrimLeft(char* szBuf);
void StrTrimRight(char* szBuf);
void StrTrimAll(char* szBuf);
long GetFileSize(char* lpszFileName);
int ReadLineFromFile(FILE* IniFile, char* lpszLineBuf, int iLen); //从指定文件中读取一行内容
bool IfBeforeHasRet(FILE* pFile); //辅助函数，判断当前文件位置前面是否是换行符号
//读配置文件中指定段下指定键的值(字符串)
int QGetPrivateProfileString(
char* lpszSectionName, //段名
char* lpszKeyName, //键名
char* lpszDefault, //缺省字符串
char* lpszReturnedString, //结果字符串
u_32 nSize, //结果字符串长度
char* lpszFileName, //ini文件名
char* lpszRemarkInLineStr = (char*)";", //行内注释符
char chContinueLineChar = '\\' //续行符号
);
//读配置文件中指定段下指定键的值(整数)
int QGetPrivateProfileInt(
char* lpszSectionName, //段名
char* lpszKeyName, //键名
int nDefault, //缺省值
char* lpszFileName, //ini文件名
char* lpszRemarkInLineStr = (char*)";", //行内注释符
char chContinueLineChar = '\\' //续行符号
);
//向配置文件写入指定段下指定键的值(字符串)
int QWritePrivateProfileString(
char* lpszSectionName, //段名
char* lpszKeyName, //键名
char* lpszString, //要写入的字符串
char* lpszFileName //INI文件名
);
#endif

103
list_entry.cpp
Unescape Escape View File

@ -0,0 +1,103 @@
/************************************************************************
*
* Copyright (C) 2003-2004
* Shenzhen SCADA Control Technology Co., Ltd.
* All rights reserved.
*
* 实现双链表
*
* 创建日期: 2004/01/10
*
* $Id: list_entry.cpp,v 1.1.1.1 2006/07/05 07:31:43 jehu Exp $
*
***********************************************************************/
#include <sys/types.h>
#include "list_entry.h"
/*
* 双向链表的操纵例程函数的实现
*/
void Initialize_list_head ( list_entry_t * plist_head )
{
plist_head->flink = plist_head->blink = plist_head;
}
/*
* 判断双向链表是否为空
*
* \retval 0 空链表
* \retval 非0 空链表
*/
int is_list_empty ( list_entry_t * plist_head )
{
return (int)(plist_head->flink == plist_head);
}
/*
* 从双向链表的头部移取一个链表元素--与链表脱离链接关系
*/
list_entry_t * remove_head_list ( list_entry_t * plist_head )
{
list_entry_t * pHeadEntry = plist_head->flink;
remove_entry_list ( plist_head->flink );
return pHeadEntry;
}
/*
* 从双向链表的尾部移取一个链表元素--与链表脱离链接关系
*/
list_entry_t * remove_tail_list ( list_entry_t * plist_head )
{
list_entry_t * pHeadEntry = plist_head->blink;
remove_entry_list ( plist_head->blink );
return pHeadEntry;
}
/*
* 从双向链表中移取制定的链表元素--与链表脱离链接关系
*/
void remove_entry_list ( list_entry_t * pEntry )
{
list_entry_t * _EX_Blink = (list_entry_t *)0;
list_entry_t * _EX_Flink = (list_entry_t *)0;
_EX_Flink = pEntry->flink;
_EX_Blink = pEntry->blink;
_EX_Blink->flink = _EX_Flink;
_EX_Flink->blink = _EX_Blink;
}
/*
* 将一个链表元素从尾部插入到双向链表中
*/
void insert_tail_list ( list_entry_t * plist_head, list_entry_t * pEntry )
{
list_entry_t * _EX_Blink = (list_entry_t *)0;
list_entry_t * _EX_ListHead = (list_entry_t *)0;
_EX_ListHead = plist_head;
_EX_Blink = _EX_ListHead->blink;
pEntry->flink = _EX_ListHead;
pEntry->blink = _EX_Blink;
_EX_Blink->flink = pEntry;
_EX_ListHead->blink = pEntry;
}
/*
* 将一个链表元素从尾部插入到双向链表中
*/
void insert_head_list ( list_entry_t * plist_head, list_entry_t * pEntry)
{
list_entry_t * _EX_Flink = (list_entry_t *)0;
list_entry_t * _EX_ListHead = (list_entry_t *)0;
_EX_ListHead = plist_head;
_EX_Flink = _EX_ListHead->flink;
pEntry->flink = _EX_Flink;
pEntry->blink = _EX_ListHead;
_EX_Flink->blink = pEntry;
_EX_ListHead->flink = pEntry;
}

107
list_entry.h
Unescape Escape View File

@ -0,0 +1,107 @@
/************************************************************************
*
* Copyright (C) 2003-2004
* Shenzhen SCADA Control Technology Co., Ltd.
* All rights reserved.
*
* 双链表
*
* 创建日期: 2004/01/10
*
* 摘自Windoes $(DDKPATH)/inc/ntdef.h和$(DDKPATH)/inc/ddk/ntddk.h
*
* $Id: list_entry.h,v 1.1.1.1 2006/07/05 07:31:43 jehu Exp $
*
***********************************************************************/
#ifndef __LIST_ENTRY_H__SKLJFALKJZLJVADFHOPSHVPZIOXJHCVOIPADFDFNXVCQWEDAH
#define __LIST_ENTRY_H__SKLJFALKJZLJVADFHOPSHVPZIOXJHCVOIPADFDFNXVCQWEDAH
/*!
* 双向链表结构定义, 可以用链表的头或者链表成员.
*/
typedef struct tag_list_entry_t {
struct tag_list_entry_t * flink; /*!< 指向链表元素的前驱元素 */
struct tag_list_entry_t * blink; /*!< 指向链表元素的后继元素 */
} list_entry_t;
typedef list_entry_t * plist_entry_t;
typedef list_entry_t ** pplist_entry_t;
/*
* 下面是双向链表的操纵例程函数
*
* +---------------------------+-----------------------------------------------------+
* | Initialize_list_head | 初始化链表头中的list_entry_t结构 |
* +---------------------------+-----------------------------------------------------+
* | is_list_empty | 判断链表是否为空 |
* +---------------------------+-----------------------------------------------------+
* | remove_head_list | 从双向链表的头部移取一个链表元素--与链表脱离链接关系|
* +---------------------------+-----------------------------------------------------+
* | remove_tail_list | 从双向链表的尾部移取一个链表元素--与链表脱离链接关系|
* +---------------------------+-----------------------------------------------------+
* | remove_entry_list | 从双向链表中移取指定的链表元素--与链表脱离链接关系 |
* +---------------------------+-----------------------------------------------------+
* | insert_tail_list | 在起始处插入一个元素 |
* +---------------------------+-----------------------------------------------------+
* | insert_head_list | 在结尾处插入一个元素 |
* +---------------------------+-----------------------------------------------------+
* | CONTAINING_RECORD | 由链表元素指针反演出链表元素所包含的元素指针 |
* +---------------------------+-----------------------------------------------------+
*
*/
/*
* 由链表元素指针反演出链表元素所包含的元素指针
*/
#ifdef CONTAINING_RECORD
#undef CONTAINING_RECORD
#endif
#define CONTAINING_RECORD(_addr, _type, _field) ((_type *)((char *)(_addr) - (char *)(&((_type *)0)->_field)))
/*
* 初始化双向链表
*
* \param plist_head 指向链表的头
*/
void Initialize_list_head ( list_entry_t * plist_head );
/*
* 判断双向链表是否为空
*
* \retval 0 空链表
* \retval 非0 空链表
*/
int is_list_empty ( list_entry_t * plist_head );
/*
* 从双向链表的头部移取一个链表元素--与链表脱离链接关系
*/
list_entry_t * remove_head_list ( list_entry_t * plist_head );
/*
* 从双向链表的尾部移取一个链表元素--与链表脱离链接关系
*/
list_entry_t * remove_tail_list ( list_entry_t * plist_head );
/*
* 从双向链表中移取制定的链表元素--与链表脱离链接关系
*/
void remove_entry_list ( list_entry_t * pEntry);
/*
* 将一个链表元素从尾部插入到双向链表中
*/
void insert_tail_list ( list_entry_t * plist_head, list_entry_t * pEntry );
/*
* 将一个链表元素从头部插入到双向链表中
*/
void insert_head_list ( list_entry_t * plist_head, list_entry_t * pEntry);
#endif /* __LIST_ENTRY_H__SKLJFALKJZLJVADFHOPSHVPZIOXJHCVOIPADFDFNXVCQWEDAH */

871
netport.cpp
Unescape Escape View File

@ -0,0 +1,871 @@
/*****************************************************************************
* FileName : netport.c *
* Programmer : Li Liangchu *
* Writen at : 2004.07.21 *
* Version : *
* Description: base on net comm sports driver *
* Last modify: 2004.07.21 *
*****************************************************************************/
//#include "serialport.h"
#include "netport.h"
#include "commport.h"
int netWSAStartupErr = FALSE;
extern SIO_PARAM_DEF SioParam[];
extern u_short MaxSerialPortNum;
extern u_short MaxNetPortNum;
extern u_short MaxPortNum;
//创建 UDP 通讯 socket
BYTE CreateUdpSock(int *CommSock, DWORD NetPort, DWORD NetCommIpAddr)
{
int tmp, retval;
struct sockaddr_in addr;
u_long largp = 1L; //非阻塞模式
char tmp_buf[256];
if(*CommSock > -1)
return SOCKET_BEING;
if((NetPort == 0) && (NetCommIpAddr == 0))
return FAIL_GREATE;
*CommSock = socket(AF_INET, SOCK_DGRAM, 0);
if(*CommSock < 0)
{
*CommSock = -1;
return FAIL_GREATE;
}
// 将socket设置为非阻塞模式
//tmp = fcntl(*CommSock, F_GETFL, 0);
//fcntl(*CommSock, F_SETFL, tmp|O_NONBLOCK);
retval = ioctlsocket(*CommSock, FIONBIO, (u_long FAR *)&largp);
if (SOCKET_ERROR == retval)
{
retval = WSAGetLastError();
sprintf(tmp_buf, "ioctlsocket设置非阻塞模式错误, SocketError=%d, SocketId = %d", retval, *CommSock);
DebugPrint(tmp_buf);
closesocket(*CommSock);
*CommSock = -1;
return FAIL_GREATE;
}
//设置socket输入输出缓冲
tmp = MAX_NET_BUF_SIZE;
setsockopt(*CommSock, SOL_SOCKET, SO_RCVBUF, (char*)&tmp, sizeof(tmp));
tmp = MAX_NET_BUF_SIZE;
setsockopt(*CommSock, SOL_SOCKET, SO_SNDBUF, (char*)&tmp, sizeof(tmp));
tmp = 1;
setsockopt(*CommSock, SOL_SOCKET, SO_KEEPALIVE, (char*)&tmp, sizeof(tmp));
setsockopt(*CommSock, SOL_SOCKET, SO_REUSEADDR, (char*)&tmp, sizeof(tmp));
// 增加udp广播通讯(广播地址)
if((NetCommIpAddr & 0x000000FF) == 0x000000FF)
{
setsockopt(*CommSock, SOL_SOCKET, SO_BROADCAST, (char*)&tmp, sizeof(tmp));
}
//让配置socket 能收不同网段的配置命令
//bzero(&addr, sizeof(addr));
memset((char*)&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(NetPort);
addr.sin_addr.s_addr = htonl(INADDR_ANY);
if(bind(*CommSock, (struct sockaddr *)&addr, sizeof(addr)) < 0)
{
closesocket(*CommSock);
*CommSock = -1;
return FAIL_GREATE;
}
return SUCCEED_GREATE;
}
//创建 TCP Server socket
BYTE CreateTcpServerSock(int *LiSock, DWORD NetPort)
{
int i, tmp, ret, retval, len;
int keep_alive = 1; // 设定KeepAlive
int keep_idle = 5; // 开始首次KeepAlive探测前的TCP空闭时间(s)
int keep_interval = 3; // 两次KeepAlive探测间的时间间隔(s)
int keep_count = 3; // 判定断开前的KeepAlive探测次数
struct sockaddr_in addr;
u_long largp = 1L; //非阻塞模式
char tmp_buf[256];
if(-1 < *LiSock)
return SOCKET_BEING;
if(NetPort == 0)
return FAIL_GREATE;
*LiSock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
//len = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
//*LiSock = len;
if(*LiSock < 0)
{
retval = WSAGetLastError();
sprintf(tmp_buf, "ioctlsocket设置非阻塞模式错误, SocketError=%d, SocketId = %d", retval, *LiSock);
*LiSock = -1;
return FAIL_GREATE;
}
// 将socket设置为非阻塞模式
//tmp = fcntl(*LiSock, F_GETFL, 0);
//fcntl(*LiSock, F_SETFL, tmp|O_NONBLOCK);
retval = ioctlsocket(*LiSock, FIONBIO, (u_long FAR *)&largp);
if (SOCKET_ERROR == retval)
{
retval = WSAGetLastError();
sprintf(tmp_buf, "ioctlsocket设置非阻塞模式错误, SocketError=%d, SocketId = %d", retval, *LiSock);
DebugPrint(tmp_buf);
closesocket(*LiSock);
*LiSock = -1;
return FAIL_GREATE;
}
///设置socket的输入输出缓冲区大小
tmp = MAX_NET_BUF_SIZE;
setsockopt(*LiSock, SOL_SOCKET, SO_RCVBUF, (char*)&tmp, sizeof(tmp));
tmp = MAX_NET_BUF_SIZE;
setsockopt(*LiSock, SOL_SOCKET, SO_SNDBUF, (char*)&tmp, sizeof(tmp));
len = 4;
tmp_buf[0] = 1;
tmp = setsockopt(*LiSock, SOL_SOCKET, SO_KEEPALIVE, tmp_buf, len);
tmp = getsockopt(*LiSock, SOL_SOCKET, SO_KEEPALIVE, tmp_buf, &len);
tmp = 1;
// setsockopt(*LiSock, SOL_SOCKET, SO_KEEPALIVE, (char*)&tmp, sizeof(tmp));
setsockopt(*LiSock, SOL_SOCKET, SO_REUSEADDR, (char*)&tmp, sizeof(tmp));
//set_keepalive(*LiSock, keep_alive, keep_idle, keep_interval, keep_count);
//让TCP接收所有连线
memset((char*)&addr,0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(NetPort);
addr.sin_addr.s_addr = htonl(INADDR_ANY);
//printf("TIP_(%04d): Port = %d, NetCommIpAddr(%08x), addr.sin_addr.s_addr(%08x)\n", getpid(), commid+1, *NetCommIpAddr, addr.sin_addr.s_addr);
if(bind(*LiSock, (struct sockaddr *)&addr, sizeof(addr)) < 0)
{
//printf("errno = %d\n", errno);
//close(*LiSock);
closesocket(*LiSock);
*LiSock = -1;
return FAIL_GREATE;
}
//printf("succeed!\n");
ret = listen(*LiSock, 4);
if(ret < 0)
{
//close(*LiSock);
closesocket(*LiSock);
*LiSock = -1;
return FAIL_GREATE;
}
return SUCCEED_GREATE;
}
//创建 TCP Client socket
BYTE CreateTcpClientSock(int *CommSock, DWORD NetPort, DWORD NetCommIpAddr)
{
int tmp,len;
int keep_alive = 1; // 设定KeepAlive
int keep_idle = 5; // 开始首次KeepAlive探测前的TCP空闭时间
int keep_interval = 3; // 两次KeepAlive探测间的时间间隔
int keep_count = 3; // 判定断开前的KeepAlive探测次数
struct sockaddr_in addr;
u_long largp = 1L; //非阻塞模式
char tmp_buf[256];
if(-1 < *CommSock)
return SOCKET_BEING;
if((NetPort == 0) && (NetCommIpAddr == 0))
return FAIL_GREATE;
*CommSock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if(*CommSock < 0)
{
*CommSock = -1;
return FAIL_GREATE;
}
// 将socket设置为非阻塞模式
//tmp = fcntl(*CommSock, F_GETFL, 0);
//fcntl(*CommSock, F_SETFL, tmp|O_NONBLOCK);
tmp = ioctlsocket(*CommSock, FIONBIO, (u_long FAR *)&largp);
if (SOCKET_ERROR == tmp)
{
tmp = WSAGetLastError();
sprintf(tmp_buf, "ioctlsocket设置非阻塞模式错误, SocketError=%d, SocketId = %d", tmp, *CommSock);
DebugPrint(tmp_buf);
closesocket(*CommSock);
*CommSock = -1;
return FAIL_GREATE;
}
///设置socket的输入输出缓冲区大小
tmp = MAX_NET_BUF_SIZE;
setsockopt(*CommSock, SOL_SOCKET, SO_RCVBUF, (char*)&tmp, sizeof(tmp));
tmp = MAX_NET_BUF_SIZE;
setsockopt(*CommSock, SOL_SOCKET, SO_SNDBUF, (char*)&tmp, sizeof(tmp));
len = 4;
tmp_buf[0] = 1;
tmp = setsockopt(*CommSock, SOL_SOCKET, SO_KEEPALIVE, tmp_buf, len);
tmp = getsockopt(*CommSock, SOL_SOCKET, SO_KEEPALIVE, tmp_buf, &len);
tmp = 1;
// setsockopt(*CommSock, SOL_SOCKET, SO_KEEPALIVE, (char*)&tmp, sizeof(tmp));
setsockopt(*CommSock, SOL_SOCKET, SO_REUSEADDR, (char*)&tmp, sizeof(tmp));
// set_keepalive(*CommSock, keep_alive, keep_idle, keep_interval, keep_count);
//bzero(&addr, sizeof(addr));
memset((char*)&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(NetPort);
addr.sin_addr.s_addr = htonl(NetCommIpAddr);
//printf("TIP_(%04d): Port = %d, connect(%08x)\n", getpid(), commid+1, *NetCommIpAddr);
if(connect(*CommSock, (struct sockaddr *)&addr, sizeof(addr)) != 0)
{
//printf(" connect error errno= %d, EINPROGRESS=%d\n", errno,EINPROGRESS);
if(EINPROGRESS != errno)
{
closesocket(*CommSock);
//printf(" connect error errno= %d, EINPROGRESS=%d\n", errno,EINPROGRESS);
*CommSock = -1;
return FAIL_GREATE;
}
// 非阻塞的情况下不能这样使用
// else
// {
// if(connect(*CommSock, (struct sockaddr *)&addr, sizeof(addr)) < 0)
// {
// //printf(" connect error errno= %d, EISCONN=%d\n", errno,EISCONN);
// if(EISCONN != errno)
// {
// printf(" connect error errno= %d, EISCONN=%d\n", errno,EISCONN);
// close(*CommSock);
// *CommSock = -1;
// return FAIL_GREATE;
// }
// }
// //printf(" connect succeed errno= %d EISCONN=%d\n", errno, EISCONN);
// }
}
return SUCCEED_GREATE;
}
//int keep_alive = 1;//设定KeepAlive
//int keep_idle = 1;//开始首次KeepAlive探测前的TCP空闭时间
//int keep_interval = 1;//两次KeepAlive探测间的时间间隔
//int keep_count = 3;//判定断开前的KeepAlive探测次数
/*void set_keepalive(int fd, int keep_alive, int keep_idle, int keep_interval, int keep_count)
{
if(keep_alive)
{
if(setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (void*)&keep_alive, sizeof(keep_alive)) == -1)
{
fprintf(stderr, "setsockopt SOL_SOCKET::SO_KEEPALIVE failed, %s\n",strerror(errno));
}
if(setsockopt(fd, SOL_TCP, TCP_KEEPIDLE, (void *)&keep_idle,sizeof(keep_idle)) == -1)
{
fprintf(stderr, "setsockopt SOL_TCP::TCP_KEEPIDLE failed, %s\n", strerror(errno));
}
if(setsockopt(fd,SOL_TCP,TCP_KEEPINTVL, (void *)&keep_interval, sizeof(keep_interval)) == -1)
{
fprintf(stderr, "setsockopt SOL_tcp::TCP_KEEPINTVL failed, %s\n", strerror(errno));
}
if(setsockopt(fd,SOL_TCP,TCP_KEEPCNT, (void *)&keep_count,sizeof(keep_count)) == -1)
{
fprintf(stderr, "setsockopt SOL_TCP::TCP_KEEPCNT failed, %s\n", strerror(errno));
}
}
}*/
void OpenNetPort(int commid)
{
BYTE succeedflag;
int i, commsock;
DWORD netport, netcommipaddr;
commsock = SioParam[commid].CommSock;
netport = SioParam[commid].NetPort;
netcommipaddr = SioParam[commid].NetCommIpAddr;
switch(SioParam[commid].NetType)
{
case UDP_COMM: // UDP 通讯
if(OPEN_PORT == SioParam[commid].OpenFlag)
return;
succeedflag = CreateUdpSock(&commsock, netport, netcommipaddr);
if(SUCCEED_GREATE == succeedflag)
{
SioParam[commid].OpenFlag = OPEN_PORT;
SioParam[commid].CommSock = commsock;
}
break;
case TCP_S_COMM: // TCP 服务器通讯
commsock = SioParam[commid].LiSock;
succeedflag = CreateTcpServerSock(&commsock, netport);
if(SUCCEED_GREATE == succeedflag)
{
for(i=MaxSerialPortNum; i<MaxPortNum; i++)
{
if(TCP_S_COMM == SioParam[i].NetType)
{
if(SioParam[i].NetPort == netport)
{
printf("端口%d netport=%d lisock=%d\n", i+1, netport, commsock);
SioParam[i].LiSock = commsock;
}
}
}
}
break;
case TCP_C_COMM: // TCP 客户通讯
if(OPEN_PORT == SioParam[commid].OpenFlag)
return;
succeedflag = CreateTcpClientSock(&commsock, netport, netcommipaddr);
if(SUCCEED_GREATE == succeedflag)
{
SioParam[commid].CommSock = commsock;
//if(commid == 8)
//printf("端口%d 创建TCP 客户端成功，socket=%d\n", commid+1, SioParam[commid].CommSock);
}
break;
}
}
void CloseNetPort(int commid)
{
switch(SioParam[commid].NetType)
{
case UDP_COMM: // UDP 通讯
if(SioParam[commid].CommSock > -1)
closesocket(SioParam[commid].CommSock);
SioParam[commid].CommSock = -1;
if(CLOSE_PORT != SioParam[commid].OpenFlag)
{
SioParam[commid].OpenFlag = CLOSE_PORT;
}
break;
case TCP_S_COMM: // TCP 服务器通讯
if(SioParam[commid].CommSock > -1)
closesocket(SioParam[commid].CommSock);
//printf("关闭端口%d TCP客户端Socket=%d\n", commid+1, SioParam[commid].CommSock);
SioParam[commid].CommSock = -1;
if(CLOSE_PORT != SioParam[commid].OpenFlag)
{
SioParam[commid].OpenFlag = CLOSE_PORT;
}
break;
case TCP_C_COMM: // TCP 客户端通讯
if(SioParam[commid].CommSock > -1)
closesocket(SioParam[commid].CommSock);
SioParam[commid].CommSock = -1;
//printf("关闭端口%d TCP客户端Socket=%d\n", commid+1, SioParam[commid].CommSock);
if(CLOSE_PORT != SioParam[commid].OpenFlag)
{
SioParam[commid].OpenFlag = CLOSE_PORT;
}
break;
}
// 删除所有的发送缓冲区wen 2005.07.27
PortWriteDataFree(commid);
}
// TCP服务器端的侦听socket关闭与打开与端口是否打开的标识(SioParam[commid].OpenFlag)无关
void CloseNetListenPort(int commid)
{
int i;
switch(SioParam[commid].NetType)
{
case TCP_S_COMM: // TCP 服务器通讯
if(SioParam[commid].LiSock > -1)
//close(SioParam[commid].LiSock);
closesocket(SioParam[commid].LiSock);
SioParam[commid].LiSock = -1;
// 使用相同TCP服务端口的端口的listen套接字全部标识为－1(关闭)
for(i=MaxSerialPortNum; i<MaxPortNum; i++)
{
if(SioParam[i].LiSock == SioParam[commid].LiSock)
SioParam[i].LiSock = -1;
}
break;
case UDP_COMM: // UDP 通讯
break;
case TCP_C_COMM: // TCP 客户端通讯
break;
}
}
// UDP网络通讯接收数据
void UdpRecv(int commid, int fds, u_long ipaddr)
{
int len;
char revbuf[MAX_MSG_BUF_SIZE];
struct sockaddr_in addr;
int addr_len = sizeof(struct sockaddr_in);
// 将该socket中的数据读完
do
{
len = recvfrom(fds, revbuf, MAX_MSG_BUF_SIZE, 0, (struct sockaddr *)&addr, &addr_len);
if(addr.sin_addr.s_addr == ipaddr)
{
if(IsBaoHuPtr(commid))
{
PutDataToBuf(&SioParam[commid].RecvBuf, (u_char*)revbuf, len);
}
}
}while(len >= MAX_MSG_BUF_SIZE);
}
//从头结点往后删
void DelNode(int commid)
{
struct WR_DATA *next;
if (!SioParam[commid].WriteData)
{
return;
}
//SioParam[commid].iWriteDataNo--;
next = SioParam[commid].WriteData->Next;
HEAP_FREE(SioParam[commid].WriteData);
SioParam[commid].WriteData = next;
}
void UdpSend(int commid)
{
int len, plen, slen;
struct sockaddr_in addr;
if(!IsBaoHuPtr(commid))
return;
if(NULL == SioParam[commid].WriteData)
return;
//bzero(&addr, sizeof(addr));
memset((char*)&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(SioParam[commid].NetPort);
addr.sin_addr.s_addr = SioParam[commid].NetCommIpAddr;
// 错误判断和断点续传
plen = SioParam[commid].WriteData->PLen;
slen = SioParam[commid].WriteData->MsgLen - plen;
if(slen <= 0)
{
DelNode(commid);
return;
}
len = sendto(SioParam[commid].CommSock,(const char*)&SioParam[commid].WriteData->MsgData[plen], slen,
0, (struct sockaddr *)&addr, sizeof(struct sockaddr_in));
if(len > 0)
{
if(len < slen)
{
if(EINPROGRESS != errno)
{
CloseNetPort(commid);
}
else
{
SioParam[commid].WriteData->PLen += len;
}
}
else
{
DelNode(commid);
}
//ShmAddSendCount(commid, len);
}
else if(EINPROGRESS != errno)
{
CloseNetPort(commid);
}
}
BOOL TcpRecv(int commid, int fds, u_long ipaddr)
{
BOOL bRetVal;
int len, nread;
char revbuf[MAX_MSG_BUF_SIZE];
// if(OPEN_PORT != SioParam[commid].OpenFlag)
// return FALSE;
bRetVal = TRUE;
//删除已断开的子socket
//ioctl(fds, FIONREAD, &nread);
/*if(nread == 0)
{
//if(commid == 8)
// printf("TIP_(%04d): Port=%d Peer Socket is closed already.\n", getpid(), commid+1);
CloseNetPort(commid);
bRetVal = FALSE;
}
else*/
{
do
{
len = recv(fds, revbuf, MAX_MSG_BUF_SIZE, 0);
// 错误判断 len = 0 有可能是对方已经关闭socket
if(len <= 0)
{
printf("port%d read error len=%d\n", commid+1, len);
if(EINPROGRESS != errno)
{
//printf("port%d read error\n", commid+1);
CloseNetPort(commid);
bRetVal = FALSE;
break;
}
}
if(IsBaoHuPtr(commid))
{
PutDataToBuf(&SioParam[commid].RecvBuf, (u_char*)revbuf, len);
}
}while(len >= MAX_MSG_BUF_SIZE);
}
return bRetVal;
}
void TcpSend(int commid)
{
int len, plen, slen;
if(OPEN_PORT != SioParam[commid].OpenFlag)
{
SioParam[commid].OpenFlag = OPEN_PORT;
//printf("设置Tcp端口%d 端口状态为OPEN_PORT！\n", commid+1);
}
else
{
if(!IsBaoHuPtr(commid))
{
return;
}
if(NULL == SioParam[commid].WriteData)
{
return;
}
// 增加错误判断和断点续传
plen = SioParam[commid].WriteData->PLen;
slen = SioParam[commid].WriteData->MsgLen - plen;
if(slen <= 0)
{
DelNode(commid);
return;
}
len = send(SioParam[commid].CommSock,(const char*)&SioParam[commid].WriteData->MsgData[plen], slen, 0);
if(len > 0)
{
if(len < slen)
{
if(EINPROGRESS != errno)
{
//printf("端口%d 发送错误，关闭Tcp通讯\n", commid+1);
CloseNetPort(commid);
}
else
{
SioParam[commid].WriteData->PLen += len;
}
}
else
{
DelNode(commid);
}
//ShmAddSendCount(commid, len);
}
else if(EINPROGRESS != errno)
{
//printf("端口%d 不能发送数据，关闭Tcp通讯\n", commid+1);
CloseNetPort(commid);
}
}
}
void TcpAccept(int commid, int lisfds)
{
int sock, result, i, addr_len, tmp;
struct sockaddr_in addr;
int keep_alive = 1; // 设定KeepAlive
int keep_idle = 5; // 开始首次KeepAlive探测前的TCP空闭时间
int keep_interval = 3; // 两次KeepAlive探测间的时间间隔
int keep_count = 3; // 判定断开前的KeepAlive探测次数
fd_set set;
u_long largp = 1L; //非阻塞模式
char tmp_buf[256];
addr_len = sizeof(struct sockaddr_in);
//printf("端口%d 检查是否有客户端过来连接\n", commid+1);
sock = accept(lisfds, (struct sockaddr *)&addr, &addr_len);
if(sock < 0)
{
return;
}
printf("TIP_(%04d): Port = %d, addr.sin_addr.s_addr(%08x), sock = %d\n", _getpid(), commid+1, addr.sin_addr.s_addr, sock);
// 多客户端向服务端连接时判断客户端来自的端口号 yizhonghu 20070704
for(i=MaxSerialPortNum; i<MaxPortNum; i++)
{
if((SioParam[i].NetCommIpAddr == addr.sin_addr.s_addr)
&& (SioParam[i].LiSock == lisfds))
{
printf("sockport = %d\n", i+1);
commid = i;
break;
}
}
if(i == MaxPortNum)
{
closesocket(sock);
return;
}
// 如果socket已经存在，则关掉原来的连接建立新的连接 yizhonghu 20070705
if(SioParam[commid].CommSock < 0)
{
closesocket(SioParam[commid].CommSock);
}
SioParam[commid].CommSock = sock;
//result = fcntl(sock, F_GETFL, 0);
//fcntl(sock, F_SETFL, result|O_NONBLOCK);
result = ioctlsocket(sock, FIONBIO, (u_long FAR *)&largp);
if (SOCKET_ERROR == result)
{
result = WSAGetLastError();
sprintf(tmp_buf, "ioctlsocket设置非阻塞模式错误, SocketError=%d, SocketId = %d", result, sock);
DebugPrint(tmp_buf);
return;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
result = MAX_NET_BUF_SIZE;
setsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char*)&result, sizeof(result));
result = MAX_NET_BUF_SIZE;
setsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char*)&result, sizeof(result));
result = 4;
tmp_buf[0] = 1;
tmp = setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, tmp_buf, result);
tmp = getsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, tmp_buf, &result);
result = 1;
setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char*)&result, sizeof(result));
//set_keepalive(sock, keep_alive, keep_idle, keep_interval, keep_count);
// 这里应该等到确定端口可以写再设置为完全打开状态
//SioParam[commid].OpenFlag = OPEN_PORT;
}
int AddFdToSet(int commid, int *fd_max, fd_set *fdset_ro, fd_set *fdset_wr, fd_set *fdset_ex)
{
int setflag, fds, inum;
inum = 0;
setflag = 0;// (=0: 无操作; =1:没有后续操作; =2:当前无操作，但有后续操作;=3:有操作并有后续操作)
switch (SioParam[commid].NetType)
{
case NO_COMM:
break;
case UDP_COMM: // 检查UDP端口套接字是否建立
if (-1 < SioParam[commid].CommSock)
{
fds = SioParam[commid].CommSock;
setflag = 3;
break;
}
setflag = 2;
break;
case TCP_S_COMM: // 检查TCP服务器端口套接字是否建立(包括listen套接字)
if ((0 > SioParam[commid].CommSock) && (-1 < SioParam[commid].LiSock))
{
fds = SioParam[commid].LiSock;
setflag = 3;
break;
}
if (-1 < SioParam[commid].CommSock)
{
fds = SioParam[commid].CommSock;
setflag = 3;
break;
}
setflag = 2;
break;
case TCP_C_COMM: // 检查TCP客户端套接字是否建立
if (-1 < SioParam[commid].CommSock)
{
fds = SioParam[commid].CommSock;
setflag = 3;
break;
}
setflag = 2;
break;
}
if (0 == setflag)
return inum;
if ((1 == setflag) || (3 == setflag))
{
inum++;
FD_SET(fds, fdset_ro);
FD_SET(fds, fdset_wr);
FD_SET(fds, fdset_ex);
*fd_max = max(*fd_max, fds);
}
if (1 == setflag)
return inum;
// if(2 == setflag) 无需处理
return inum;
}
void PollAllPort(void)
{
struct timeval timeout;
int i, inum, nfds, commid, fds, lisfds, ret, ierr, ierrlen;
u_long ipaddr;
fd_set fdset_ro, fdset_wr, fdset_ex;
/*static int ok=0;*/
inum = 0;
nfds = 0;
FD_ZERO(&fdset_ro);
FD_ZERO(&fdset_wr);
FD_ZERO(&fdset_ex);
for(i=0; i<MaxPortNum; i++)
{
commid = i;
inum += AddFdToSet(commid, &nfds, &fdset_ro, &fdset_wr, &fdset_ex);
}
if(inum < 1)
return;
// 设置超时等待时间为0
memset((char*)&timeout, 0, sizeof(struct timeval));
if(select(nfds+1, &fdset_ro, &fdset_wr, &fdset_ex, &timeout) < 1)
{
return;
}
for(i=0; i< MaxPortNum; i++)
{
commid = i;
fds = SioParam[commid].CommSock;
ipaddr = SioParam[commid].NetCommIpAddr;
switch(SioParam[commid].NetType)
{
case NO_COMM:
break;
case UDP_COMM:
if(SioParam[commid].CommSock < 0)
break;
// 判断socket是否异常
if(FD_ISSET(fds, &fdset_ex))
{
CloseNetPort(commid);
break;
}
// socket可读
if(FD_ISSET(fds, &fdset_ro))
UdpRecv(commid, fds, ipaddr);// 将该socket中的数据读完
// socket可写
if(FD_ISSET(fds, &fdset_wr))
UdpSend(commid);
break;
case TCP_C_COMM:
if(SioParam[commid].CommSock < 0)
break;
// 判断socket是否异常
if(FD_ISSET(fds, &fdset_ex))
{
CloseNetPort(commid);
break;
}
// socket可读
if(FD_ISSET(fds, &fdset_ro))
{
if(TcpRecv(commid, fds, ipaddr) == FALSE) // 将该socket中的数据读完
break; // 端口可能已经关闭
}
// socket可写
if(FD_ISSET(fds, &fdset_wr))
{
ierrlen = sizeof(ierr);
ret = getsockopt (fds, SOL_SOCKET, SO_ERROR, (char *)&ierr, &ierrlen);
if (SOCKET_ERROR == ret)
{
CloseNetPort(commid);
break;
}
TcpSend(commid);
}
break;
case TCP_S_COMM:
lisfds = SioParam[commid].LiSock;
/*if(ok < 1000)
{
printf("端口%d lisock=%d fds = %d\n", commid+1, lisfds, fds);
ok++;
}*/
if(fds < 0)
{
if(lisfds < 0)
break;
if(FD_ISSET(lisfds, &fdset_ex))
{
//printf("端口%d 关闭服务器端口\n", commid+1);
CloseNetListenPort(commid);
}
else if(FD_ISSET(lisfds, &fdset_ro))
{
TcpAccept(commid, lisfds);
}
break;
}
// 判断socket是否异常
if(FD_ISSET(fds, &fdset_ex))
{
//printf("端口%d socket异常，关闭Tcp通讯\n", commid+1);
CloseNetPort(commid);
break;
}
// socket可读
if(FD_ISSET(fds, &fdset_ro))
{
if(TcpRecv(commid, fds, ipaddr) == FALSE) // 将该socket中的数据读完
break; // 端口可能已经关闭
}
// socket可写
if(FD_ISSET(fds, &fdset_wr))
TcpSend(commid);
break;
}
}
// 服务器端口读写数据
}

36
netport.h
Unescape Escape View File

@ -0,0 +1,36 @@
/*****************************************************************************
* FileName : netport.h *
* Programmer : Li Liangchu *
* Writen at : 2004.07.21 *
* Version : *
* Description: base on net comm sports driver *
* Last modify: 2004.07.21 *
*****************************************************************************/
#ifndef __NET_PORT_H_ICL__
#define __NET_PORT_H_ICL__
#include "common.h"
BYTE CreateUdpSock(int *CommSock, DWORD NetPort, DWORD NetCommIpAddr);
BYTE CreateTcpServerSock(int *LiSock, DWORD NetPort);
BYTE CreateTcpClientSock(int *CommSock, DWORD NetPort, DWORD NetCommIpAddr);
// 设置及时知道TCP非优雅的方式断开连接的socket属性
//void set_keepalive(int fd, int keep_alive, int keep_idle, int keep_interval, int keep_count);
void OpenNetPort( int commid);
void CloseNetPort( int commid );
void CloseNetListenPort( int commid );
void UdpRecv(int commid, int fds, u_long ipaddr);
void UdpSend(int commid);
BOOL TcpRecv(int commid, int fds, u_long ipaddr);
void TcpSend(int commid);
// 检查连接服务器端口的客户端ip地址配置的端口
void TcpAccept(int commid, int lisfds);
void PollAllPort(void);
#endif

397
os_heap.cpp
Unescape Escape View File

@ -0,0 +1,397 @@
/************************************************************************
*
* Copyright (C) 2003-2004
* Shenzhen SCADA Control Technology Co., Ltd.
* All rights reserved.
*
* 用于调试内存泄漏的对内存分配函数的实现
*
* 创建日期: 2005/04/12
*
***********************************************************************/
/*#ifdef OS_LINUX
#include <sys/types.h>
#include <sys/time.h>
#endif*/
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <string.h>
#include <errno.h>
#include "time.h"
#include "list_entry.h"
#include "os_heap.h"
//#if defined(WIN32)
#include <winsock2.h>
#include <direct.h>
#include <process.h>
//#endif
#ifdef _fclose
#undef _fclose
#endif
#define _fclose(_fp) do {if (_fp) {while (EOF == fclose((_fp)) && EINTR == errno);}} while(0)
/*!
* 堆内存块的类型
*/
typedef enum {
eMalloc = 0, /* 使用malloc分配的内存块 */
eCalloc = 1 /* 使用calloc分配的内存块 */
} heap_type_t;
/*!
* 堆内存块附加头
*
* \note
* 必须保证本结构的尺寸被16整除。
*/
typedef struct tag_heap_head_t {
/* 堆内存块附加头所在的链表的占位 */
list_entry_t anchor;
/*! 堆内存块分配发生的时间 */
struct timeval tv;
/*! 堆内存块类型 */
heap_type_t type;
/*! 堆内存块分配发生的源文件名，NULL表示匿名源文件。 */
char * fl;
/*! 堆内存块分配发生的源代码行 */
int line;
/*! 堆内存块的尺寸(字节) */
size_t size;
} heap_list_t;
/* 边界对齐量 */
#define os_heap_alignment 16
#define os_heap_pad ((sizeof(heap_list_t) % os_heap_alignment) ? (os_heap_alignment - (sizeof(heap_list_t) % os_heap_alignment)) : 0)
/* 根据数据地址求os_heap块的起始地址 */
#define os_heap_start_addr(_data) ((void *)(((unsigned char *)(_data)) - sizeof(heap_list_t) - os_heap_pad))
/* 根据os_heap块的起始地址求数据地址 */
#define os_heap_data_addr(_start) ((void *)(((unsigned char *)(_start)) + sizeof(heap_list_t) + os_heap_pad))
/* 根据数据块的尺寸求os_heap块的尺寸 */
#define os_heap_mb_size(_size) (sizeof(heap_list_t) + os_heap_pad + (_size))
/*
* 内存管理模块：
*
* 1. 初始化过程
* 2. 具有一个私有线程，专门侦听外部的信号，并打印报告。
* 3. 堆内存块链表头、尾指针。
* 4. 互斥访问保护
*/
/* 堆内存块设施是否已经初始化 */
static int g_heap_initialized = 0;
/* 堆内存块双向链表头 */
static list_entry_t g_heap_head;
/*
* 进程中使用heap_malloc/heap_calloc分配的内存
* 且现在还在使用的内存块的总数。
*/
static size_t g_heap_item_counter = 0;
/*
* 进程中使用heap_malloc/heap_calloc分配的内存
* 且现在还在使用的总量(字节)
*/
static size_t g_heap_byte_counter = 0;
/* 初始化堆内存块设施 */
static void heap_intialize();
/*!
* \brief 堆内存分配
*
* \param size 希望分配的内存的尺寸
* \param file 指向发生堆内存分配的源代码文件名称，以null字符结尾。
* 如果等于NULL， 表示匿名源代码文件名(anony)
* \param line 发生堆内存分配的源代码行号
*
* \retutrn
* 对内存分配成功的情况下，返回指向分配的内存的指针。如果内存
* 分配失败，返回NULL。
*
* \note
* 当分配的内存不在使用时，必须调用heap_free是否分配的内存。
*
* 参见 ANSI C 函数 malloc。
*/
void * heap_malloc (
size_t size,
const char * file,
int line )
{
// #ifdef DISABLE_OS_HEAP
return malloc(size);
/*#else /* #ifdef DISABLE_OS_HEAP */
/*
struct timeval tv;
char * fl = NULL;
void * mb = NULL;
heap_list_t * hl = NULL;
if (0 == size)
return NULL;
if (file) {
fl = (char *)malloc(strlen(file) + 4);
if (fl) strcpy (fl, file);
}
gettimeofday(&tv, NULL);
mb = malloc(os_heap_mb_size(size));
if (NULL == mb) {
if (fl) free (fl);
return mb;
} else {
memset (mb, 0, os_heap_mb_size(size));
}
hl = (heap_list_t *)mb;
hl->type = eMalloc;
hl->tv = tv;
hl->fl = fl;
hl->line = line;
hl->size = size;
if (!g_heap_initialized) {
heap_intialize();
g_heap_initialized = 1;
}
insert_tail_list (&g_heap_head, &(hl->anchor));
g_heap_item_counter++;
g_heap_byte_counter += hl->size;
return os_heap_data_addr(hl);
#endif *//* #ifdef DISABLE_OS_HEAP */
}
/*!
* \brief 堆内存分配, 且内存块被初始化0.
*
* \param num 内存块个数
* \param elm_size 每一个内存块的尺寸(字节)
* \param file 指向发生堆内存分配的源代码文件名称，以null字符结尾。
* 如果等于NULL， 表示匿名源代码文件名(anony)
* \param line 发生堆内存分配的源代码行号
*
* \retutrn
* 对内存分配成功的情况下，返回指向分配的内存的指针。如果内存
* 分配失败，返回NULL。
*
* \note
* 当分配的内存不在使用时，必须调用heap_free释放分配的内存。
*
* 参见 ANSI C 函数 calloc。本函数与 calloc 不同之处在于不能
* 象calloc那样保证返回的堆内存块的其实地址对齐在elm_size边界
* 上。
*/
void * heap_calloc (
size_t num,
size_t elm_size,
const char * file,
int line )
{
//#ifdef DISABLE_OS_HEAP
return calloc(num, elm_size);
//#else /* #ifdef DISABLE_OS_HEAP */
/* struct timeval tv;
char * fl = NULL;
void * mb = NULL;
heap_list_t * hl = NULL;
if (0 == num * elm_size)
return NULL;
if (file) {
fl = (char *)malloc(strlen(file) + 4);
if (fl) strcpy (fl, file);
}
gettimeofday(&tv, NULL);
mb = malloc(os_heap_mb_size(elm_size * num));
if (NULL == mb) {
if (fl) free (fl);
return mb;
} else {
memset (mb, 0, os_heap_mb_size(elm_size * num));
}
hl = (heap_list_t *)mb;
hl->type = eCalloc;
hl->tv = tv;
hl->fl = fl;
hl->line = line;
hl->size = elm_size * num;
if (!g_heap_initialized) {
heap_intialize();
g_heap_initialized = 1;
}
insert_tail_list (&g_heap_head, &(hl->anchor));
g_heap_item_counter++;
g_heap_byte_counter += hl->size;
return os_heap_data_addr(hl);
#endif *//* #ifdef DISABLE_OS_HEAP */
}
/*!
* \brief 释放堆内存
*
* \param memblock 指向先前调用heap_alloc/heap_calloc分配的内存。
*
* \return
* 无。
*/
void heap_free (void * mb)
{
#ifdef DISABLE_OS_HEAP
free (mb);
#else /* #ifdef DISABLE_OS_HEAP */
size_t sz = 0;
heap_list_t * hl = NULL;
if (NULL == mb)
return;
if (!g_heap_initialized) {
heap_intialize();
g_heap_initialized = 1;
return;
}
hl = (heap_list_t *)os_heap_start_addr(mb);
#if defined(WIN32) && (defined(DEBUG) || defined(_DEBUG))
if (IsBadReadPtr((void *)hl, sizeof(heap_list_t))) {
return;
}
if (IsBadReadPtr((void *)hl, os_heap_mb_size(hl->size))) {
return;
}
#endif
remove_entry_list (&(hl->anchor));
sz = hl->size;
if (hl->fl)
free ((void *)(hl->fl));
free ((void *)hl);
g_heap_item_counter--;
g_heap_byte_counter -= sz;
#endif /* #ifdef DISABLE_OS_HEAP */
}
/*!
* \brief 报告堆内存分配
*
* 调用本函数将堆内存分配情况以追加的方式输出到指定文件中。
*
* \param fname 对内存分配报告将输出到该文件中。如果fname等于NULL，
* 则报告将输出到标准输出上。
*
* \retval -1 函数调用失败。
* \retval 0 函数调用成功。
*
* \note
* 报告的格式如下
* 时间:
* 内存使用总量:
* ......
* 内存块列表i:
* 时间: tv
* 类型: malloc/calloc,
* 源码位置: fl(line)
* 尺寸: size
* ......
*/
int heap_report(const char * fname)
{
/* #ifndef DISABLE_OS_HEAP
int i = 0;
FILE * fp = NULL;
heap_list_t * hl = NULL;
list_entry_t * item = NULL;
list_entry_t * first = NULL;
list_entry_t * next = NULL;
char szdt[32];
if (fname) {
fp = fopen (fname, "a+t");
if (NULL == fp)
return -1;
} else
fp = stdout;
if (!g_heap_initialized) {
heap_intialize();
g_heap_initialized = 1;
if (fname) _fclose(fp);
return 0;
}
fprintf (fp, "\n"
"heap allocation summary...\n"
"time: %s\n"
"heap_item_counter: %u\n"
"heap_byte_counter: %u(bytes)\n",
cur_tm_string (szdt),
g_heap_item_counter,
g_heap_byte_counter);
first = &g_heap_head;
for ( next = first->flink; next != first; next = next->flink )
{
item = next;
hl = CONTAINING_RECORD ( item, heap_list_t, anchor );
fprintf (fp, " heap block %d:"
" times: %s"
" type: %s"
" size: %08u (bytes)"
" source: %s [%d]\n",
i++, timeval_string(&(hl->tv), szdt),
(eMalloc == hl->type ? "malloc" : "calloc"),
hl->size, (hl->fl ? hl->fl : "nony"), hl->line);
}
if (fname) _fclose(fp);
#endif*/
return 0;
}
static void heap_intialize()
{
Initialize_list_head (&g_heap_head);
}

110
os_heap.h
Unescape Escape View File

@ -0,0 +1,110 @@
/************************************************************************
*
* Copyright (C) 2003-2004
* Shenzhen SCADA Control Technology Co., Ltd.
* All rights reserved.
*
* 用于调试内存泄漏的对内存分配函数
*
* 创建日期: 2005/04/12
*
***********************************************************************/
#ifndef __OS_HEAP_H_ASDFJLCXJVZXHCROEYUIODFGFMHFOIUHSDIHFZXKJCHGVLSDHFAJD
#define __OS_HEAP_H_ASDFJLCXJVZXHCROEYUIODFGFMHFOIUHSDIHFZXKJCHGVLSDHFAJD
#include "basetype.h"
/*!
* \brief 堆内存分配
*
* \param size 希望分配的内存的尺寸
* \param file 指向发生堆内存分配的源代码文件名称，以null字符结尾。
* 如果等于NULL， 表示匿名源代码文件名(anony)
* \param line 发生堆内存分配的源代码行号
*
* \retutrn
* 对内存分配成功的情况下，返回指向分配的内存的指针。如果内存
* 分配失败，返回NULL。
*
* \note
* 当分配的内存不在使用时，必须调用heap_free是否分配的内存。
*
* 参见 ANSI C 函数 malloc。
*/
DSLIB_API void * heap_malloc (size_t size, const char * file, int line);
/*!
* \brief 堆内存分配, 且内存块被初始化0.
*
* \param num 内存块个数
* \param elm_size 每一个内存块的尺寸(字节)
* \param file 指向发生堆内存分配的源代码文件名称，以null字符结尾。
* 如果等于NULL， 表示匿名源代码文件名(anony)
* \param line 发生堆内存分配的源代码行号
*
* \retutrn
* 对内存分配成功的情况下，返回指向分配的内存的指针。如果内存
* 分配失败，返回NULL。
*
* \note
* 当分配的内存不在使用时，必须调用heap_free释放分配的内存。
*
* 参见 ANSI C 函数 calloc。本函数与 calloc 不同之处在于不能
* 象calloc那样保证返回的堆内存块的其实地址对齐在elm_size边界
* 上。
*/
DSLIB_API void * heap_calloc (size_t num, size_t elm_size,
const char * file, int line);
/*!
* \brief 释放堆内存
*
* \param mb 指向先前调用heap_alloc/heap_calloc分配的内存。
*
* \return
* 无。
*/
DSLIB_API void heap_free (void * mb);
/*!
* \brief 报告堆内存分配
*
* 调用本函数将堆内存分配情况以追加的方式输出到指定文件中。
*
* \param fname 对内存分配报告将输出到该文件中。如果fname等于NULL，
* 则报告将输出到标准输出上。
*
* \retval -1 函数调用失败。
* \retval 0 函数调用成功。
*/
DSLIB_API int heap_report (const char * fname);
/*
* 堆内存分配和释放宏定义, 为了方便使用者而提供这些宏定义。
*
* 1. HEAP_MALLOC(_size)
* 2. HEAP_CALLOC(_num, _elm_size)
* 3. HEAP_FREE(_mb)
*/
#define HEAP_MALLOC(_size) heap_malloc((_size), __FILE__, __LINE__)
#define HEAP_CALLOC(_num, _elm_size) heap_calloc((_num), (_elm_size), __FILE__, __LINE__)
#define HEAP_FREE(_mb) do{if(_mb) {heap_free((_mb)); (_mb) = NULL;}} while(0)
#ifdef DISABLE_OS_HEAP
#undef HEAP_MALLOC
#undef HEAP_CALLOC
#undef HEAP_FREE
#define HEAP_MALLOC(_size) malloc(_size)
#define HEAP_CALLOC(_num, _elm_size) calloc(_num, _elm_size)
#define HEAP_FREE(_mb) do {if (_mb) {free(_mb); (_mb) = NULL;}} while(0)
#endif
#endif /* __OS_HEAP_H_ASDFJLCXJVZXHCROEYUIODFGFMHFOIUHSDIHFZXKJCHGVLSDHFAJD */

162
platform_def.h
Unescape Escape View File

@ -0,0 +1,162 @@
/*-----------------------------------------------------------------------------
platform_def.h 操作系统相关定义 zl 2002.11.5
本文件定义所有和操作系统平台相关的常量、类型、宏及头文件引用
-----------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------
条件编译常量定义约定：
(1) Windows操作系统: OS_WINDOWS
(2) Unix(统称)操作系统: OS_UNIX
(3) Linux操作系统: _OS_UNIX_LINUX_
(4) True64操作系统: _OS_UNIX_TRUR64_
(5) Solaris操作系统: _OS_UNIX_SOLARIS_
(6) 64位操作系统: _OS_64BIT_
(7) Windows字节顺序: _OS_WINDOWS_BYTEORDER_
(8) Solaris字节顺序: _OS_SOLARIS_BYTEORDER_
[说明]：
a. 64位操作系统主要有：DEC True64, solaris(有时可能是32位系统,可以通过测试sizeof
(long)是否=8来判断)
b. windows, linux, true64 等操作系统的字节顺序和solaris相反,因此分别以Windows
和solaris为代表定义不同的字节顺序
c. Unix操作系统种类繁多，每个变种有一定的差别，因此为常见的unix系统每种定义一个
条件编译常量
-----------------------------------------------------------------------------*/
#ifndef PLATFORM_DEF_H
#define PLATFORM_DEF_H
/*------------------------------------ 头文件引用 --------------------------------*/
#ifdef OS_WINDOWS //windows
#include <windows.h>
#include <dos.h>
#include <direct.h>
#include <time.h>
#endif
#ifdef OS_UNIX //unix
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/msg.h>
#include <sys/shm.h>
#include <sys/time.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <arpa/inet.h> //inet地址族的所有结构和常量定义都在这里
#include <netinet/in.h>
#include <errno.h>
#include <stropts.h>
#include <stddef.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#include <pthread.h>
#include <string.h>
// #include <time.h>
#include <netdb.h> //定义bsd socket的gethostbyname()函数
#endif
/*------------------------------------ 名字定义 --------------------------------*/
//全局名字替换名字,为减少移植时大量修改结构及函数名的工作量而设置
#ifdef OS_UNIX
#define SYSTEMTIME QSYSTEMTIME
#define GetLocalTime QGetLocalTime
#define SetLocalTime QSetLocalTime
#define GetPrivateProfileString QGetPrivateProfileString
#define GetPrivateProfileInt QGetPrivateProfileInt
#define WritePrivateProfileString QWritePrivateProfileString
#define closesocket close //winsock中关闭socket用closesocket(),而bsd socket中用close()
#endif
/*-------------------------------- 类型定义 ------------------------------------*/
#ifdef OS_UNIX
typedef unsigned char BYTE;
typedef unsigned char u_char;
typedef unsigned char UCHAR;
typedef unsigned long DWORD;
typedef unsigned short WORD;
typedef unsigned short u_short;
typedef unsigned short USHORT;
typedef int BOOL;
typedef int INT;
typedef unsigned int u_int;
typedef unsigned int UINT;
typedef unsigned int SOCKET; //为编译通过而临时从Winsock.h中提取的类型定义
typedef unsigned long u_long;
typedef unsigned long ULONG;
#endif
#ifdef _OS_64BIT_
typedef int i_32; //固定长度为4个字节的有符号整数类型
typedef unsigned int u_32; //固定长度为4个字节的无符号整数类型
typedef long _int64; //Vc中64位整数_int64在64位unix下对应long(8个字节), dnp30.cpp中引用
#else
typedef long i_32;
typedef unsigned long u_32;
#ifdef OS_UNIX
typedef int64_t _int64; //Vc中64位整数_int64在32位unix下对应int64_t,在sys/types.h中定义
#endif
#endif
#ifdef OS_UNIX
typedef u_32 DWORD; //DWORD为固定长度4个字节的无符号整数
#endif
/*----------------------------------- 常数定义 ----------------------------------*/
#ifdef OS_UNIX
#define TRUE 1
#define FALSE 0
#define NULL 0
#define INVALID_SOCKET (SOCKET)(~0) //为编译通过而临时从Winsock.h中提取的类型定义
#define SOCKET_ERROR (-1)
#define INADDR_NONE 0xffffffff
#endif
/*------------------------------------ 宏定义 -----------------------------------*/
#ifdef OS_UNIX
#define MAKEWORD(a, b) ((WORD)(((BYTE)(a)) | ((WORD)((BYTE)(b))) << 8))
#define MAKELONG(a, b) ((LONG)(((WORD)(a)) | ((DWORD)((WORD)(b))) << 16))
#define LOWORD(l) ((WORD)(l))
#define HIWORD(l) ((WORD)(((DWORD)(l) >> 16) & 0xFFFF))
#define LOBYTE(w) ((BYTE)(w))
#define HIBYTE(w) ((BYTE)(((WORD)(w) >> 8) & 0xFF))
#define max(a,b) (((a) > (b)) ? (a) : (b))
#define min(a,b) (((a) < (b)) ? (a) : (b))
#endif
/*-------------------------------------------------------------------------------*/
#endif //PLATFORM_DEF_H

246
portconfig.ini
Unescape Escape View File

@ -0,0 +1,246 @@
[Port1]
Protocol=buban103
CommMode=9600,e,8,1
WorkMode=RS-485
HandshakeMode=NO_HANDSHAKE
XonXoff=0000
AiNum=128
DiNum=256
PiNum=0
Retry=1
RetryTime=3
WaitTime=0
ykyttimeout=20
PortType=0
CheckTime=NO
#@@规约配置
时间同步过程=60.00
总查询过程=60.00
电度量查询=300.00
通用分类数据模拟量查询=3.00
通用分类数据状态量查询=3.00
链路数量=1
链路1模板文件名称=port103ser.csv
链路2模板文件名称=
链路3模板文件名称=
链路4模板文件名称=
链路5模板文件名称=
链路6模板文件名称=
上送遥信变位=0
#@@测点配置--主站
Di2CtrlNo=0
[Port2]
Protocol = modbus
CommMode = 9600,n,8,1
WorkMode = RS-485
AiNum = 128
DiNum = 256
#PiNum = 48
# 轮询指令时间配置
Retry = 1
RetryTime = 1
WaitTime = 0
# 端口类型(=0, 主站端口; =1, 子站端口)
PortType = 0
# 时间校正(=no, 不对时(缺省); =up, 上对时; =down, 下对时)
CheckTime = no
装置数量=1
装置状态输入厂站端口号 = 16
装置状态输入厂站起始点号 = 3
是否屏蔽未配置信息事件 = 0
模拟量指令 = 3,0,53
开关量指令 = 3,100,4
遥控项数=1
遥控1配置=1,16,3,0,108,8899,300,110,21930,200,110,43605,0,1,108,8899,300,109,21930,200,109,43605,0
Di1CtrlNo = 1
寄存器位数 = 16
#装置1配置信息文件名称 = mach300
装置1线路名称 =
装置1寄存器位数=16
装置1型号 = mach300
装置1地址 = 1
#模板文件名称=mach300
指令发送序列=dda
SOE状态即遥信状态=1
[Port3]
Protocol=buban103
CommMode=9600,e,8,1
WorkMode=RS-485
HandshakeMode=NO_HANDSHAKE
XonXoff=0000
AiNum=128
DiNum=256
PiNum=0
Retry=1
RetryTime=3
WaitTime=0
ykyttimeout=20
PortType=0
CheckTime=NO
#@@规约配置
时间同步过程=0
总查询过程=60.00
电度量查询=300.00
通用分类数据模拟量查询=3.00
通用分类数据状态量查询=3.00
链路数量=1
链路1模板文件名称=port103sie.csv
链路2模板文件名称=
链路3模板文件名称=
链路4模板文件名称=
链路5模板文件名称=
链路6模板文件名称=
上送遥信变位=0
#@@测点配置--主站
Di1CtrlNo=0
Di2CtrlNo=1
[Port4]
Protocol=buban103
CommMode=9600,e,8,1
WorkMode=RS-485
HandshakeMode=NO_HANDSHAKE
XonXoff=0000
AiNum=128
DiNum=256
PiNum=0
Retry=1
RetryTime=3
WaitTime=0
ykyttimeout=20
PortType=0
CheckTime=NO
装置数量 = 1
请求系统运行状态 = 10
请求交流配电信息 = 10
请求电池检测单元信息 = 10
请求馈线检测单元信息 = 10
请求绝缘监察单元信息 = 10
请求整流模块信息 = 10
请求参数设定信息 = 0
装置1地址 = 1
装置1电池数量 = 52
装置1整流模块数量 = 4
装置1名称 = gjb
[Port5]
Protocol = bypass
CommMode = 9600,n,8,1
WorkMode = RS-232
[Port6]
Protocol = bypass
CommMode = 9600,n,8,1
WorkMode = RS-232
[Port7]
Protocol = bypass
CommMode = 9600,n,8,1
WorkMode = RS-232
[Port8]
Protocol = bypass
CommMode = 9600,n,8,1
WorkMode = RS-232
[Port9]
Protocol = bypass
CommMode = 9600,n,8,1
WorkMode = RS-232
[Port10]
Protocol = bypass
CommMode = 9600,n,8,1
WorkMode = RS-232
[Port11]
Protocol = bypass
CommMode = 9600,n,8,1
WorkMode = RS-232
[Port12]
Protocol = bypass
CommMode = 9600,n,8,1
WorkMode = RS-232
[Port13]
Protocol=bypass
CommMode=9600,n,8,1
WorkMode=RS-232
[Port14]
Protocol = bypass
CommMode = 9600,n,8,1
WorkMode = RS-232
[Port15]
Protocol = bypass
CommMode = 9600,n,8,1
WorkMode = RS-232
[Port16]
Protocol = bypass
CommMode = 9600,n,8,1
WorkMode = RS-232
[Port17]
Protocol=scadaprotect
NetCommMode=TCP,Server
NetPort=8000
NetCommAddr=127.0.0.1
AiNum=0
DiNum=0
PiNum=0
Retry=1
RetryTime=3
WaitTime=0
ykyttimeout=20
PortType=1
CheckTime=NO
#@@规约配置
模板文件名称=scada.csv
[Port18]
Protocol=buban104
NetCommMode=TCP,Server
NetPort=2404
NetCommAddr=192.168.111.168
AiNum=128
DiNum=256
PiNum=64
Retry=1
RetryTime=3
WaitTime=0
ykyttimeout=20
PortType=1
CheckTime=UP
#@@规约配置
站地址=1
总召唤电度数据=120.00
召唤初始化数据=300.00
帧序应答=20.00
超时时间=3.00
转发返校超时时间=0.00
转发是否要求应答=0
超时发送测试帧=0
遥控方式=0
遥测信息体起始地址=1793
遥信信息体起始地址=1
遥脉信息体起始地址=3073
遥控信息体起始地址=2817
版本号=1
#@@测点配置--从站
ProvAi1=1a1,1
ProvAi1Inc=18
ProvAi20=2a1,1
ProvAi21=2a2,1
ProvAi22=2a3,1
ProvAi23=2a5,1
ProvAi24=2a6,1
ProvAi25=2a7,1
ProvAi26=2a9,1
ProvAi27=2a10,1
ProvAi28=2a11,1
ProvAi29=2a16,1
ProvAi30=2a17,1
ProvAi31=2a1,1
ProvAi32=3a1,1
ProvAi32Inc=16
ProvDi1=2d1,1
ProvDi2=2d17
ProvDi3=2d33
ProvDi4=2d49
[Port19]
Protocol = bypass
CommMode = 9600,n,8,1
WorkMode = RS-232
[Port20]
Protocol = bypass
CommMode = 9600,n,8,1
WorkMode = RS-232

2405
scadaprotect.cpp
View File

File diff suppressed because it is too large Load Diff

516
scadaprotect.h
Unescape Escape View File

@ -0,0 +1,516 @@
/************************************************************************************
*
* Copyright (C) 2004-2005 SCADA Control Technology Co., Ltd.
* All rights reserved.
*
* 文件名称：scadaprotect.h
* 文件标识：SCADA内部保护通讯规约
* 摘 要：
*
* 当前版本：1.0
* 作 者：aaawen
* 完成日期：2005/06/02
*
* 取代版本：1.0
* 原作者 ：aaawen
* 完成日期：
*
* 说 明：数据定义规则
* u8 --- BYTE(usigned char)
* ch --- char
* w --- WORD(u_short, usigned short)
* sh --- short
* b --- BOOL(bool)
* i --- int
* l --- long
* u32 --- u_32
* ui --- unsigned int(u_int)
* ul --- unsigned long(u_long)
* f --- float
* db --- double
* c --- class
* s --- struct
* sta --- static
* g --- 全局变量
* Array --- 数组
* a --- 数组
* m_ --- 数据成员
* p --- 指针
* str --- 字符串
* 全部大写 --- 常量
* 首字节必须大写--- 类名称，结构，函数
**************************************************************************************/
// buban103.h: interface for the buban103 class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(_SCADABAOHU_H_200506020948__INCLUDED_)
#define _SCADABAOHU_H_200506020948__INCLUDED_
#ifdef OS_LINUX
#include "baohulib/common.h"
#else
#include "common.h"
#endif
//////////////////////////////////////////////////////////////////////////
// 宏定义 //
// WEN 2005.06.02 //
//////////////////////////////////////////////////////////////////////////
/*!
保护指令包(PROTECT->FEND)
*/
#define pPFV_PROTECT_BYPASS 1
/*!
保护数据包应答(FEND->PROTECT)
*/
#define fPFV_PROTECT_BYPASS_ACK 2
/*!
通道状态包(FEND->PROTECT)
*/
#define fPFV_STATUS 3
/*!
网络活动包(FEND<->PROTECT)
*/
#define fPFV_NETACTIVE 0xF0
//指令包操作码
/*!
读取定值
*/
#define hREADFIX 0x01
/*!
读取定值区号
*/
#define hREADFIXNO 0x07
/*!
读取保护模拟量
*/
#define hREADPAI 0x09
/*!
读取保护开关量
*/
#define hREADPDI 0x0b
/*!
读取保护波形数据
*/
#define hREADPWAVE 0x0d
/*!
读取指定故障报告
*/
#define hQUERYFAULT 0x11
/*!
读取指定的自检报告
*/
#define hQUERYSELFCHECK 0x12
/*!
修改保护定值
*/
#define hWRITEALLFIX 0x15
/*!
修改指定的保护定值
*/
#define hWRITESPECIALFIX 0x16
/*!
保护定值确认
*/
#define hWRITEFIXACK 0x17
/*!
保护定值不确认
*/
#define hWRITEFIXNAK 0x18
/*!
修改保护定值区
*/
#define hWRITEFIXNO 0x19
/*!
定值区修改确认
*/
#define hWRITEFIXNOACK 0x1a
/*!
定值区修改不确认
*/
#define hWRITEFIXNONAK 0x1b
/*!
保护信号复归
*/
#define hRESETPROTECT 0x1c
/*!
单个装置对时
*/
#define hCHECKTIME 0x1d
/*!
保护装置广播对时
*/
#define hBROADCASTCHECKTIME 0x1e
/*!
读取保护装置状态
*/
#define hSTATUS 0x1f
/*!
读取菜单单元值
*/
#define hCOMMAND 0x20
/*!
读取扰动参数的命令
*/
#define hDISTCOMMAND 0x21
/*!
保护操作取消
*/
#define hCANCEL 0xFF
//应答包操作码
/*!
数据申请中
*/
#define hREADINGDATA 0x02
/*!
定值数据
*/
#define hFIXDATA 0x03
/*!
数据申请结束
*/
#define hREADDATAEND 0x04
/*!
数据申请无响应
*/
#define hNORESPONSE 0x05
/*!
数据处理繁忙，稍后重试
*/
#define hSYSTEMBUSY 0x06
/*!
定值区号数据
*/
#define hFIXNODATA 0x08
/*!
保护模拟量数据
*/
#define hPAIDATA 0x0a
/*!
保护开关量数据
*/
#define hPDIDATA 0x0c
/*!
保护波行数据上送开始
*/
#define hPWAVEDATASTART 0x0e
/*!
保护波行数据
*/
#define hPWAVEDATA 0x0f
/*!
保护波行数据上送结束
*/
#define hPWAVEDATAEND 0x10
/*!
带索引号的事件报告数据
*/
#define hPEVENTDATAWITHID 0x13
/*!
字符串事件报告数据
*/
#define hPEVENTDATAWITHSTRING 0x14
/*!
保护定值确认
*/
#define hWRITEFIXACK 0x17
/*!
保护定值不确认
*/
#define hWRITEFIXNAK 0x18
/*!
定值区修改确认
*/
#define hWRITEFIXNOACK 0x1a
/*!
定值区修改不确认
*/
#define hWRITEFIXNONAK 0x1b
/*!
定值数据带序号
*/
#define hFIXDATAWITHNO 0x22
/*!
保护模拟量数据带序号
*/
#define hPAIDATAWITHNO 0x23
/*!
保护开关量数据带序号
*/
#define hPDIDATAWITHNO 0x24
// 数据项目属性
/*!
实际值
*/
#define ITEM_ATTR_REALVALUE 1
/*!
缺省值
*/
#define ITEM_ATTR_DEFAULTVALUE 2
/*!
量 程
*/
#define ITEM_ATTR_MINMAXSTEP 3
/*!
备 用
*/
#define ITEM_ATTR_STANDBY 4
/*!
精 度
*/
#define ITEM_ATTR_PRECISION 5
/*!
因 子
*/
#define ITEM_ATTR_FIGURE 6
/*!
参 比
*/
#define ITEM_ATTR_RATE 7
/*!
列 表
*/
#define ITEM_ATTR_LIST 8
/*!
量 纲
*/
#define ITEM_ATTR_UNIT 9
/*!
描 述
*/
#define ITEM_ATTR_DESCRIPTION 10
/*!
保护操作超时时间(秒)
*/
#define OPERPROTECTTIMEOUT 15
// 是pc机系统还是嵌入式系统
#ifdef PC_MACHINE
#ifdef OS_WINDOWS
#pragma pack (push,1)
#else// OS_UNIX
#pragma pack(1)
#endif //OS_UNIX
#endif
typedef struct tagPROTECTCONTENTHEAD
{
u_32 ummid __attribute__ ((packed));// 操作用户
u_32 uAddr __attribute__ ((packed));// 保护地址
char cFixNo __attribute__ ((packed));// 定值区号
char cCPUNo __attribute__ ((packed));// CPU号
u_32 uFuncCode __attribute__ ((packed));// 操作功能码
u_32 uReserved __attribute__ ((packed));// 保留
}PROTECTCONTENTHEAD, *pPROTECTCONTENTHEAD;
typedef struct
{
u_32 MsgType __attribute__ ((packed));// 信息类型
u_32 PortNumber __attribute__ ((packed));// 信息端口号
u_32 MsgLen __attribute__ ((packed));// 信息长度
//u_char MsgData[1]; // 信息数据
}PROTECTMSGHEAD;
typedef struct
{
u_32 MsgType __attribute__ ((packed));// 信息类型
u_32 PortNumber __attribute__ ((packed));// 信息端口号
u_32 MsgLen __attribute__ ((packed));// 信息长度
u_char MsgData[MAX_RTU_MSG_SIZE] __attribute__ ((packed));// 信息数据
}PROTECTMSG;
// 是pc机系统还是嵌入式系统
#ifdef PC_MACHINE
#ifdef OS_WINDOWS
#pragma pack (pop)
#else// OS_UNIX
#pragma pack (0)
#endif //OS_UNIX
#endif
typedef struct
{
BOOL bPortIdle; // 端口保护操作空闲标识
u_32 timeOut; // 保护操作超时时间
u_32 mmid; // 保护操作用户
} PORTSTATUS, *pPORTSTATUS;
typedef struct tagSCADAPROVDEVDEF
{
/*!
\brief 装置的实际端口号
*/
i_32 m_iRealCommid;
/*!
\brief 装置的转发地址(唯一确定一个装置)
*/
i_32 m_iProvAddr;
/*!
\brief 转发SOE数据参数
\note
用于历史记录的转发事件(应该是没有作用，已经遗弃)
*/
DEVPROVSOE m_sProvSoe;
i_32 m_iStatusStn;
i_32 m_iStatusPnt;
DBORIENTATION m_sYxInfo;
}SCADAPROVDEVDEF;
typedef struct tagSCADAPROTECTPORTPARAM
{
/*!
\var SCADAPROTECTPORTPARAM::m_achRecvBuf
\brief 接收数据缓冲区
\note
缓冲区最大不超过 MAX_RTU_MSG_SIZE+12(包头) bytes\n
*/
char m_achRecvBuf[MAX_RTU_MSG_SIZE+12];
/*!
\var SCADAPROTECTPORTPARAM::m_iRecvLen
\brief 接收数据长度
*/
int m_iRecvLen;
/*!
\var SCADAPROTECTPORTPARAM::m_iRecvLen
\brief 网络活动包的发送时间
*/
int m_iActiveTimeCnt;
int m_iActiveTimeConst;
/*!
\var SCADAPROTECTPORTPARAM::m_iRecvLen
\brief 通道状态包的发送时间
*/
int m_iStatusTimeCnt;
int m_iStatusTimeConst;
/*!
保护装置数量
*/
i_32 m_iDevNum;
SCADAPROVDEVDEF *m_psProvDev;
SINGLELIST m_sBaoHuData;
char m_chArrayTempletFileName[256];
PORTSTATUS *m_pPrtPortStatus;
/*!
\brief 该规约的端口数据指针
*/
SIO_PARAM_BAOHU_DEF *m_psBaoHu;
}SCADAPROTECTPORTPARAM, *pSCADAPROTECTPORTPARAM;
/////////////////////////以下为通用函数接口///////////////////////////
/*!
\brief 读取配置函数
\param commid -- 端口号
\note
取值范围：0 -- MaxSerialPortNum + MaxNetPortNum -1\n
*/
void ScadaProtectReadConfig(int commid); // 初始化处理
/*!
\brief 读取端口数据函数
\param commid -- 端口号
\note
取值范围：0 -- MaxSerialPortNum + MaxNetPortNum -1\n
\param buf -- 数据源缓冲区指针
\param len -- 数据源长度
*/
void ScadaProtectRecvData(int commid, u_char *buf, int len);// 规约读数据处理
/*!
\brief 规约数据处理定时器函数
\param commid -- 端口号
\note
取值范围：0 -- MaxSerialPortNum + MaxNetPortNum -1\n
*/
void ScadaProtectTimer(int commid); // 定时器处理
/*!
\brief 遥控遥调数据处理函数
\param commid -- 端口号
\note
取值范围：0 -- MaxSerialPortNum + MaxNetPortNum -1\n
\param buf -- 数据源缓冲区指针
\param len -- 数据源长度
*/
void ScadaProtectYkYtProcess(int commid, u_char *buf, int len); // 遥控遥调处理
/*!
\brief 系统下发对时函数
\param commid -- 端口号
\note
取值范围：0 -- MaxSerialPortNum + MaxNetPortNum -1\n
*/
//void ScadaProtectSendSystemTime(int commid); // 系统对时
/*!
\brief 系统退出时规约处理函数
\param commid -- 端口号
\note
取值范围：0 -- MaxSerialPortNum + MaxNetPortNum -1\n
*/
void ScadaProtectExit(int commid); // 规约退出
/*!
\brief 保护命令处理函数
\param commid -- 端口号
\param rtumsg -- 下发的保护命令指针
\note
取值范围：0 -- MaxSerialPortNum + MaxNetPortNum -1\n
*/
void ScadaProtectBaoHuCmdProcess(int commid, RTUMSG *rtumsg, BOOL bUpData);
/*!
\brief 取保护数据库指针函数
\param commid -- 端口号
\param iProvAddr -- 统一编排的保护转发地址
\param ppBaoHuDB -- 存放保护数据指针的指针
\retval -- 返回该装置保护数据组数
*/
int ScadaProtectGetBaohuDataBase(int commid, int iProvAddr, GROUPDEF **ppBaoHuDB);
/////////////////////////通用函数接口结束///////////////////////////////
/////////////////////////以下为通用函数支持接口/////////////////////////
void ScadaProtectProvMakeYkYtCommand(int commid, u_char *buf, int len);
/////////////////////////通用函数支持接口结束///////////////////////////
///////////////////////////以下为配置函数接口///////////////////////////
BOOL InitScadaInfoFromTempletFile(int commid, SCADAPROTECTPORTPARAM *psPortParam,\
char *ptrTemplate, BOOL bMaster);
BOOL GetProvDevNumFromTemplateFileScada(int commid, HDSFILE hFile, SCADAPROTECTPORTPARAM *psPortParam);
BOOL GetProvDevParamFromTemplateFileScada(int commid, HDSFILE hFile, SCADAPROTECTPORTPARAM *psPortParam);
int FindProtectDevFromPntNoScada(SCADAPROTECTPORTPARAM *psPortParam, int iPntNo, int itype);
/////////////////////////////配置函数接口结束///////////////////////////
///////////////////////以下为规约处理函数接口///////////////////////////
void ReduceTimeOut(SCADAPROTECTPORTPARAM *psPortParam);
BOOL IsProtectPortIdle(int commid, SCADAPROTECTPORTPARAM *psPortParam);
BOOL GetProtectPortIdle(int commid, SCADAPROTECTPORTPARAM *psPortParam, PORTSTATUS *pStatus);
BOOL SetProtectPortIdle(int commid, SCADAPROTECTPORTPARAM *psPortParam, PORTSTATUS *pStatus);
BOOL SetProtectPortIdleEx(int commid, int iBaoHuCommid, PORTSTATUS *pStatus);
void SendResponsetoMMI(int commid, int mmid, u_32 ResponseType, PROTECTMSG *pmsg);
//将客户机报文所有的数据从网络字节循序转换成主机字节顺序函数
void AllNetToHostByteSequence(PROTECTMSG *userdata);
//将客户机报文所有的数据从主机字节顺序转换成网络字节顺序函数
void AllHostToNetByteSequence(PROTECTMSG *userdata);
BOOL ScadaProtectConvertToScadaFrameAndSend(int commid);
BOOL ScadaProtectConvertTo103AndSend(int commid, PROTECTMSG *pmsg);
//数据处理函数总入口
void ScadaProtectProcessData(int commid, SCADAPROTECTPORTPARAM *psPortParam, BOOL bProcess);
void ScadaProtectByPassData(int commid, SCADAPROTECTPORTPARAM *psPortParam, PROTECTMSG *pmsg);
BOOL FormatDataAndSend(int commid, PROTECTMSG *pmsg);
void MakeInteractionCmd(int commid, int sourcommid, u_32 ResponseFunc, PROTECTCONTENTHEAD *pSourHead, BOOL bBoardCast);
void MakeNetActivePacket(int commid);
void MakeStatusPacket(int commid);
BOOL MakeSoeDataPacket(int commid);
/////////////////////////规约处理函数接口结束///////////////////////////
/////////////////////////以下为调试函数接口/////////////////////////////
void DispPrtPortStatus(int commid, SCADAPROTECTPORTPARAM *psPortParam);
///////////////////////////调试函数接口结束/////////////////////////////
#endif // !defined(_SCADABAOHU_H_200506020948__INCLUDED_)

3218
tcphost.cpp
View File

File diff suppressed because it is too large Load Diff

299
tcphost.h
Unescape Escape View File

@ -0,0 +1,299 @@
/************************************************************************************
*
* Copyright (C) 2002-2003 SCADA Control Technology Co., Ltd. All rights reserved.
*
* $Source: /opt/CVS_ROOT_PGC_EX2000/commserver/windows/widgets/tcphost.h,v $
*
* $Author: jehu $
*
* $Date: 2006/07/05 07:31:44 $
*
* $Revision: 1.1.1.1 $
*
* $State: Exp $
*
* $Name: $
*
* $Locker: $
*
* $Log: tcphost.h,v $
* Revision 1.1.1.1 2006/07/05 07:31:44 jehu
* no message
*
* Revision 1.5 2006/05/26 10:38:03 administrator
* 增加32位模拟量传送
*
* Revision 1.4 2006/04/22 07:49:26 administrator
* 可以屏蔽网络连接的错误信息，支持端口通讯时不切换主备机及网络连接成功的算法
*
* Revision 1.2 2006/01/17 06:14:53 Administrator
* 增加对时、装置并列运行以及端口号偏移
*
* Revision 1.1 2005/10/20 06:20:34 Administrator
* 新增前置机功能
*
* Revision 1.1 2005/10/12 06:03:46 Administrator
* 增加前置机功能
*
*
**************************************************************************************/
//***************************************************************
//* TcpHost.h *
//* Liangchu Lee 1999.12.20 *
//***************************************************************
#ifndef __TCPHOST_H_ICL__
#define __TCPHOST_H_ICL__
#include "common.h"
// 另外一个前置机装置是pc还是ds-3116
#define FEND_OTHERDEV_DS3116 1
#define HOST_CLOSE_NET 1
#define OVER_TIME_CLOSE_NET 2
#define FEND_CLOSE_NET 3
#define ERROR_CLOSE_NET 4
#define CHECK_VERSION_FLAG 1
// 运行方式是主备方式
#define RUN_MODE_STANDBY 0
// 并列方式，同时运行
#define RUN_MODE_ALLHOT 1
//**************** 端口数据类型 ************************
#define iCOMM_DATA 0x10 // RTU数据包类型
//************ 前置机 --> 主机 数据类型 ****************
#define iREQUESTHOSTSTATUS 0x14 // 请求主机状态
#define iTIMEINFORM 0x2c // 前置机对时
#define iAIDATA 0x31 // 变化遥测
#define iDIDATA 0x32 // 变化遥信
#define iPIDATA 0x33 // 变化电度
#define iSOEDATA 0x34 // SOE 数据
#define iACKDATA 0x35 // 遥控遥调返校
#define WUXI_ZHUANFA_AI_TO_HOST 0x36
#define WUXI_ZHUANFA_DI_TO_HOST iDIALLDATA
#define WUXI_ZHUANFA_PI_TO_HOST 0x37
#define iODDATA 0x38 // 离线遥信数据
#define iODALLDATA 0x39 // 离线遥信全数据
#define iWUFANGYKYTREQ 0x3d // 五防遥控遥调请求
#define iAIALLDATA 0x40 // 遥测全数据
#define iDIALLDATA 0x41 // 遥信全数据
#define iPIALLDATA 0x42 // 电度全数据
// wen 2006.05.20 32bit传送模拟量数据
#define PGC3_AI32DATA 0x45 // 变化32位遥测数据
#define PGC3_AI32ALLDATA 0x46 // 遥测32位全数据
#define iBYPASSDATA 0x50 // 直通数据
#define iODPOINT 0x81 // 读离线量点数据
#define iANPOINT 0x82 // 读模拟量点数据
#define iDIPOINT 0x83 // 读数字量点数据
#define iLINESTATUS 0x84 // 端口线路状态
#define iNETTESTMSG 0xf0 // 网络状态包
#define iNETNAMEPLATE 0xef // 网络标示包
//************ 主机 --> 前置机 数据类型 ****************
#define hHOSTSTATUS 0x15 // 主机状态
#define NET_PROFILE_UPDATE 0x1B // 主机下发更改数据库指令
#define hTIMEINFORM 0x2c // 主机对时
#define hYKYTCMD 0x35 // 遥控遥调命令
#define hBYPASSCMD 0x50 // 直通数据
#define hMAPANDATA 0x82 // 模拟量点数据
#define hMAPDIDATA 0x83 // 数字量点数据
#define hDATA_OUTPUT_CTRL 0x85 // 数据输出控制
#define hRELOADDATABASE 0x86 // 重新装入数据库
#define hNETTESTMSG 0xf0 // 网络状态包
#define hMAPALLOP 0xf4 // 模拟盘全盘操作
//*********************数据缓冲区************************
#define AIMSGNO 0
#define DIMSGNO 1
#define SOEMSGNO 2
#define YKYTACKNO 3
#define ODMSGNO 4
#define PIMSGNO 5
#define RTUCHANGMSGNUM 6
//******************************************************
typedef struct tagTCP_SEND_DATA_BUF
{
int MsgLen __attribute__ ((packed));
BYTE MsgData[MAX_NET_BUF] __attribute__ ((packed));
} TCP_SEND_DATA_BUF;
typedef struct tagTCP_RCV_DATA_BUF
{
int MsgCnt __attribute__ ((packed));// 信息内容计数
int Front __attribute__ ((packed));// 信息取数指针
int Rear __attribute__ ((packed));// 信息存入指针
BYTE MsgData[MAX_NET_BUF] __attribute__ ((packed));// 信息数据
} TCP_RCV_DATA_BUF;
typedef struct tagFEND_DEF
{
char Name[MAX_MACHINE_NAME_LEN] __attribute__ ((packed));
int FendIdx __attribute__ ((packed));
int LinkFlag __attribute__ ((packed));
int EnableLink __attribute__ ((packed));
char SetTcpIpAddr[MAX_FEND*MAX_ADDR][TCPIP_ADDR_LEN] __attribute__ ((packed));
char TcpIpAddr[MAX_ADDR][TCPIP_ADDR_LEN] __attribute__ ((packed));
u_long HostIpAddr[MAX_ADDR] __attribute__ ((packed));
u_long AllIpAddr[MAX_ADDR] __attribute__ ((packed));
u_long BroadCastAddr[MAX_ADDR] __attribute__ ((packed));
int LinkStatus[MAX_FEND] __attribute__ ((packed));
int LinkCnt[MAX_FEND] __attribute__ ((packed));
int FendExistFlag[MAX_FEND] __attribute__ ((packed));
int FendExistCnt[MAX_FEND] __attribute__ ((packed));
int SendTxdDataFlag[MAX_FEND] __attribute__ ((packed));
// wen 2006.01.14 增加装置的起始厂站号的偏移
int iPortOffset __attribute__ ((packed));
int iRunMode __attribute__ ((packed));
// wen 2006.04.22 主备切换时，判断的端口通讯状态屏蔽字(按位屏蔽)
int iPortMask __attribute__ ((packed));
// wen 2006.05.20 32bit传送模拟量数据
int iSendAiof32Bit __attribute__ ((packed));
} FEND_DEF;
typedef struct tagTCP_LINK_DEF
{
u_char InitFlag __attribute__ ((packed));// 初始化标志
u_char InitOk __attribute__ ((packed));// 初始化成功标志
long InitLinkCnt __attribute__ ((packed));// 初始化计数
char ExistFlag __attribute__ ((packed));// 存在标志
u_char CommFlag __attribute__ ((packed));// 通讯标志
u_char Status __attribute__ ((packed));// 工作状态
long StatusCnt __attribute__ ((packed));// 状态计数
SOCKET SocketId __attribute__ ((packed));// 连接号
u_char LinkType __attribute__ ((packed));// 连接类型
char CurLinkIdx __attribute__ ((packed));
u_char TcpIpAddr[MAX_ADDR][TCPIP_ADDR_LEN] __attribute__ ((packed));// Tcp/Ip 地址
u_char VersionFalgByte __attribute__ ((packed));// 服务器版本号标志
int RevHostStatusMsg __attribute__ ((packed));// 接收主机广播信息
char NetNameplateFalg __attribute__ ((packed));
int iNoWriteNum __attribute__ ((packed));
} TCP_LINK_DEF;
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// 兼容老系统的RTUMSG结构
typedef struct tagORTUMSGHEAD
{
u_char MsgType __attribute__ ((packed));// 信息类型
u_char PortNumber __attribute__ ((packed));// 信息端口号
short MsgLen __attribute__ ((packed));// 信息长度
} ORTUMSGHEAD;
typedef struct tagORTUMSG
{
u_char MsgType __attribute__ ((packed));// 信息类型
u_char PortNumber __attribute__ ((packed));// 信息端口号
short MsgLen __attribute__ ((packed));// 信息长度
u_char MsgData[MAX_RTU_MSG_SIZE] __attribute__ ((packed));// 信息数据
} ORTUMSG;
typedef struct tagHOSTMSGHEAD
{
WORD MsgType __attribute__ ((packed));// 信息类型
WORD PortNumber __attribute__ ((packed));// 信息端口号
WORD MsgLen __attribute__ ((packed));// 信息长度
WORD EMsgLen __attribute__ ((packed));// 扩展信息长度
} HOSTMSGHEAD;
typedef struct tagHOSTMSG
{
WORD MsgType __attribute__ ((packed));// 信息类型
WORD PortNumber __attribute__ ((packed));// 信息端口号
WORD MsgLen __attribute__ ((packed));// 信息长度
WORD EMsgLen __attribute__ ((packed));// 扩展信息长度
u_char MsgData[MAX_RTU_MSG_SIZE] __attribute__ ((packed));// 信息数据
} HOSTMSG;
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
BOOL GetConfigName(char *szFileName, int iFileNameLen, int IsPortConfig);
BOOL IsWouldBlock();
BOOL IsWouldBlockEx(int neterrno);
int GetNetErrorNo();
void CloseNetSocket(SOCKET sock);
void ULongToIPString(char *ipstr, u_long ipulong);
void InitSetTcpIpAddr(void);
void SendNetNameplateMsgToHost(int flag);
BOOL InitFendMsg(void);
BOOL InitHostWSAStartup(void);
void FindCurrentFend(void);
void LinkOneHost(int hostid);
void HostConnect(SOCKET socket, WORD error);
void LinkToHost(void);
void CloseHostSocket(SOCKET socket, int flag);
void CloseHost(void);
BOOL ReadHost(int hostid);
int GetHostMsgFormHostRevBuf(HOSTMSG *hostmsg, int hostid);
BOOL ReadDataFormHost(SOCKET socket);
int SendDataToHostSendBuf(int hostid, u_char *buf, int len, BOOL bInsert);
void SendDataToAllHostSendBuf(u_char *buf, int len);
void SendHostSendBufToHost(void);
void ClearSendBuffer(int hostid);
void ClearRecvBuffer(int hostid);
// 服务器数据处理及发送
void HostDataProceWithSignalYkYt(HOSTMSG *hmsg);
void HostDataProce(HOSTMSG *hostmsg);
void SendRtuChangeDataToHost(void);
void SendPortStatisticsToHost(void);
void SendPortStatusToHost(int flag);
void SendPortAllDataToHost(void);
void SetSoeData(int commidex, SOE_DEF *pSoeData);
void SetYkYtAckData(int portno, char *buf);
void SelectHostSocketEvent(void);
void SelectHostSocketEventEx(void);
void TcpHostTimer(void);
// 服务器模拟盘数据处理
void MapAnPointToHost(int iMapOutPort, int iMapSavePort);
void MapDiPointToHost(int iMapOutPort, int iMapSavePort);
void FormHostMapDataProce(int iMapOutPort, int iMapSavePort, HOSTMSG *msg);
// 获取前置机的下发标识
int GetFendTxdFlag(void);
// 判断网络地址是否是前置机地址
int CheckIsFendIpAddr(u_long addr);
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// 前置机功能函数
void WriteChangeData(int commidex, int point, void *pntmsg, BYTE type);
BOOL IsSendDatatoPort(int port);
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// 获取全局变量
TCP_LINK_DEF *GetHostLinkPtr();
FEND_DEF *GetFendMsgPtr();
HOSTMSG *GetRtuChangeMsgPtr();
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// 增加字节顺序转换函数
BOOL AllDataHostToRtuByteSequence(HOSTMSG *hmsg, ORTUMSG *pSendMsg);
BOOL AllDataRtuToHostByteSequence(HOSTMSG *hmsg);
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void SendSystemTimeToHost(void);
#endif

372
typedef.h
Unescape Escape View File

@ -0,0 +1,372 @@
/*************************************************************************************
*
* Copyright (C) 1999-2000 SCADA Technology Control Co., Ltd. All rights reserved.
*
* 作者: 杨小波
*
* 日期: 2001/08/07
*
* 说明:
* 最基本的类型定义.
* 1: 基本类型的长度(字节单位)
* 2: 定义可移植类型
*
*************************************************************************************/
#ifndef __TYPEDEF_H__DFJGLWREPUEPISXVCMAFGLJHQEWPYRPEOAJLKGZNCNALDHFPQEWUPOQRJSJHGAQ
#define __TYPEDEF_H__DFJGLWREPUEPISXVCMAFGLJHQEWPYRPEOAJLKGZNCNALDHFPQEWUPOQRJSJHGAQ
/*!
* \if developer_doc
* \file
*
* \brief 最基本的类型定义
*
* id: $Id: typedef.h,v 1.2 2006/08/04 03:37:33 zhuzhenhua Exp $
*
* \author 杨小波 prcharold@sina.com.cn develop1@szscada.com
* \endif
*/
#include <sys/types.h>
/*!
* 定义最基本的类型, 这些类型可以在不同的操作系统中保持字节长度不变,
* 便于在不同的操作系统环境中, PGC系列软件之间交换数据和文件
*
* 单字节数据类型 //(SIZE_OF_CHAR = sizeof(char))
*/
#define SIZE_OF_CHAR 1
#if SIZE_OF_CHAR == 1
typedef char pgcchar;
typedef char pgc8;
typedef signed char int8;
typedef signed char i_8;
typedef unsigned char u_char;
typedef unsigned char pgcu_char;
typedef unsigned char pgcbyte;
typedef unsigned char PGCBYTE;
typedef unsigned char pgcu8;
typedef unsigned char u_8;
typedef unsigned char BYTE;
#else
#error "Please choose a 1 byte data type to redefine pgcchar."
#endif /* SIZE_OF_CHAR == 1 */
#define SIZE_OF_SHORT 2
/*!
* 双字节 //(SIZE_OF_SHORT = sizeof(short))
*/
#if SIZE_OF_SHORT == 2
typedef short pgc16;
typedef short int16;
typedef short i_16;
typedef unsigned short pgcu16;
typedef unsigned short pgcword;
typedef unsigned short PGCWORD;
typedef unsigned short u_16;
typedef unsigned short u_short;
typedef unsigned short WORD;
#else
#error "Please choose a 2 byte data type to redefine pgc16."
#endif //SIZE_OF_SHORT == 2
#define SIZE_OF_LONG 4
#define SIZE_OF_INT 4
/*!
* 双字节 (SIZE_OF_LONG = sizeof(long))
*/
#if SIZE_OF_LONG == 4 && SIZE_OF_INT == 4
typedef int pgc32;
typedef int int32;
typedef unsigned int pgcu32;
typedef unsigned int pgcdword;
typedef unsigned int PGCDWORD;
typedef unsigned int u32;
/*#if OS_WINDOWS
typedef unsigned int DWORD;
#endif //OS_WINDOWS*/
#elif SIZE_OF_LONG == 4
typedef long pgc32;
typedef long int32;
typedef long i_32;
typedef unsigned long pgcu32;
typedef unsigned long pgcdword;
typedef unsigned long PGCDWORD;
typedef unsigned long u_32;
typedef unsigned long DWORD;
#elif SIZE_OF_INT == 4 //(SIZE_OF_INT = sizeof(ing))
#ifndef _INTEGER_32BIT
#define _INTEGER_32BIT
typedef int pgc32;
typedef int int32;
typedef int i_32;
typedef unsigned int pgcu32;
typedef unsigned int pgcdword;
typedef unsigned int PGCDWORD;
typedef unsigned int u_32;
typedef unsigned int DWORD;
# endif
#else
#error "Please choose a 4 byte data type to redefine pgc32."
#endif //SIZE_OF_LONG == 4 and SIZE_OF_INT == 4
#define SIZE_OF_LONG 8
/*!
* 8字节 (SIZE_OF_LONG == sizeof(long))
*/
#if SIZE_OF_LONG == 8
typedef long pgc64;
typedef long int64;
typedef long i_64;
typedef unsigned long pgcu64;
typedef unsigned long pgcddword;
typedef unsigned long PGCDDWORD;
typedef unsigned long u_64;
typedef unsigned long DDWORD;
#elif OS_WINDOWS
typedef __int64 pgc64;
typedef __int64 int64;
typedef __int64 i_64;
typedef unsigned __int64 pgcu64;
typedef unsigned __int64 pgcddword;
typedef unsigned __int64 PGCDDWORD;
typedef unsigned __int64 u_64;
typedef unsigned __int64 DDWORD;
#else
typedef int64_t pgc64;
typedef int64_t int64;
typedef int64_t i_64;
typedef u_int64_t pgcu64;
typedef u_int64_t pgcddword;
typedef u_int64_t PGCDDWORD;
typedef u_int64_t u_64;
typedef u_int64_t DDWORD;
#endif //SIZE_OF_LONG == 8
#define SIZE_OF_PTR 4
/*!
* 指针 (SIZE_OF_PTR == sizeof(void *))
*/
#if SIZE_OF_PTR == 4
typedef pgc32 PGCPTR;
typedef pgc32 PTR;
typedef pgcu32 PGCUPTR;
typedef pgcu32 UPTR;
#elif SIZE_OF_PTR == 8
typedef pgc64 PGCPTR;
typedef pgc64 PTR;
typedef pgcu64 PGCUPTR;
typedef pgcu64 UPTR;
#else
#error "Please choose a data type, which size is acturally the size of pointer, to present PGCPTR"
#endif
/*!
* PGCBOOL自定义类型 -- 表达SCADA布尔量
*/
//#ifndef __PGCBOOL_DEF__
//#define __PGCBOOL_DEF__
typedef pgcu8 PGCBOOL;
#define PGCTRUE ((PGCBOOL)1)
#define PGCFALSE ((PGCBOOL)0)
//#endif //__PGCBOOL_DEF__
//#if OS_WINDOWS
//# ifndef key_t
typedef int key_t;
//# endif
//#endif // OS_WINDOWS
/*!
* ipc别名定义.
*
* 共享内存键值, 共享内存id, 信号量键值, 信号量id, 消息队列键值, 消息队列id
*
*/
typedef key_t shmkey_t, SHMKEY_t; // 共享内存键值
typedef int shmid_t, SHMID_t; // 共享内存id
typedef key_t semkey_t, SEMKEY_t; // 信号量键值
typedef int semid_t, SEMID_t; // 信号量id
typedef key_t msgkey_t, MSGKEY_t; // 消息队列键值
typedef int msgid_t, MSGID_t; // 消息队列id
/*!
* 无效的共享内存映射地址(-1)
*/
#define SHM_ADDR_INVALID ((void *)(-1))
/*!
* 和windows兼容的布尔类型定义BOOL
*/
typedef int BOOL;
/*! CAUTIOUS
* 如果, 以后站号, 点号类型的数据类型定义发生变化, 则需要修改该行
*
* 站号, 点号类型定义
*/
typedef int32 stn_no_t;
typedef int32 pnt_no_t;
/*!
* 历史数据采样类型定义
*/
typedef i_8 sampling_type_t;
/*!
* 在TRU64上, pthread_t的长度等于8, 而在linux(intel)上, pthread_t的长度
* 等于4, 所以为了兼容, 定义thd_id_t的长度为8个字节, 因此, 在非64位平台
* 上, 使用一个结构来代替
*
* 线程标识符(id)类型定义
*/
#if defined(OS_LINUX) // unix平台(肯定使用posix线程库)
#if SIZE_OF_PTHREAD_T == 8
typedef pthread_t thd_id_t;
#elif SIZE_OF_PTHREAD_T == 4
typedef struct
{
//! 低32位上定义thd_id
pthread_t thd_id;
//! 高32位保留
i_32 reserved;
} thd_id_t;
#endif
#else
#if SIZE_OF_PTHREAD_T == 8
typedef long thd_id_t;
#elif SIZE_OF_PTHREAD_T == 4
typedef struct
{
//! 低32位上定义thd_id
u_32 thd_id;
//! 高32位保留
i_32 reserved;
} thd_id_t;
#endif
#endif
/*!
* 便于移植和修改的数据类型定义.
*
* 网络套接字类型
*/
typedef int socket_t, SOCKET_t;
#define SOCKET_INVALID ((socket_t)-1)
#if defined(OS_LINUX)
#ifndef INVALID_SOCKET
#define INVALID_SOCKET (SOCKET_INVALID)
#endif //end of INVALID_SOCKET
#endif //end of defined(__unix)
/*!
* ip地址定义
*/
//typedef u_32 ip_addr_t;
#endif //__TYPEDEF_H__DFJGLWREPUEPISXVCMAFGLJHQEWPYRPEOAJLKGZNCNALDHFPQEWUPOQRJSJHGAQ
/*************************************************************************************
*
* $Revision: 1.2 $
*
* $Date: 2006/08/04 03:37:33 $
*
* $State: Exp $
*
* $Log: typedef.h,v $
* Revision 1.2 2006/08/04 03:37:33 zhuzhenhua
* no message
*
* Revision 1.11 2003/09/19 07:55:15 scada
* no message
*
* Revision 1.10 2003/08/01 06:36:19 scada
* 在Win32平台上借用__int64定义64bit的整数
*
* Revision 1.9 2003/07/01 01:31:01 scada
* no message
*
* Revision 1.8 2003/06/05 03:56:15 jehu
* 将注释修改为符合doxgen工具提取开发文档
*
* Revision 1.7 2003/01/10 10:38:40 scada
* no message
*
* Revision 1.6 2003/01/02 03:14:32 scada
* trim substitution line
*
* Revision 1.5 2002/12/04 07:47:36 scada
* for NT
*
* Revision 1.4 2002/10/07 05:37:59 harold
* cvs up -d
*
* Revision 1.3 2002/09/18 09:13:38 harold
* revised errors and warning under solaris/CC environment
*
* Revision 1.2 2002/08/26 02:07:32 harold
* 重新定义stn_no_t, pnt_no_t, sampling_type_t, 由无符号整数-->有符号整数
*
* Revision 1.1.1.1 2002/08/21 07:16:36 harold
* temporarily import
*
* Revision 1.9 2002/03/20 03:39:57 harold
* no message
*
* Revision 1.2 2002/03/17 15:33:52 harold
* changed for iccp v0.9
*
* Revision 1.1.1.1 2002/03/15 13:43:17 harold
* no message
*
* Revision 1.1.1.1 2002/03/15 08:17:07 harold
* no message
*
* Revision 1.8 2002/03/05 03:01:34 harold
* *** empty log message ***
*
* Revision 1.7 2002/03/04 14:04:39 harold
* *** empty log message ***
*
* Revision 1.6 2002/01/15 10:37:07 harold
* no message
*
* Revision 1.5 2002/01/15 10:25:42 harold
* no message
*
* Revision 1.4 2002/01/15 10:20:11 harold
* no message
*
* Revision 1.3 2002/01/15 09:55:29 harold
* no message
*
* Revision 1.2 2002/01/15 08:44:34 harold
* 添加线程id类型定义thd_id_t
*
* Revision 1.1.1.1 2001/12/24 09:33:23 harold
* no message
*
* Revision 1.2 2001/12/24 06:39:57 harold
* 为了适应不同的操作系统, 不同的CPU类型, 及不同的编译器,
* 对头文件做了相应的修改, 同时添加了一些宏定义, 如:
* HAVE__FUNCTION__, __OS__, __PLATFORM__,__TIMEZONE__等等.
*
*
*
************************************************************************************/

962
udpcomm.cpp
Unescape Escape View File

@ -0,0 +1,962 @@
//#include "stdafx.h"
#include "udpcomm.h"
#include "commport.h"
#include "udpping.h"
#include "tcphost.h"
//#include "qt_public.h"
//#include <qapplication.h>
//#include "WidgetMainWnd.h"
extern FUNCTION_CALL *FunCallPtr;
extern SIO_PARAM_DEF SioParam[];
extern int CurPort;
extern int RealDataDispFlag;
extern char IniFilePath[256];
int giRealDataToFile = 1;
UDP_SET_DEF UdpParam;
HOST_IP_ADDR HostIpAddr;
int UdpParamInitFlag = 0;
int iDevNum = 0;
int iCurDevIdx = 0;
DEV_DEF DevParam[MAX_DEV_NUM];
int SendCnt = 0;
int RecvCnt = 0;
char gCurConfigFileName[512];
void InitGlobalMember()
{
memset(gCurConfigFileName, 0, sizeof(gCurConfigFileName));
}
void GetHostIpAddr(void)
{
int i;
WSADATA WSAData;
struct hostent *test;
struct in_addr *addr, inaddr;
char name[256];
memset((char*)&HostIpAddr, 0, sizeof(HOST_IP_ADDR));
if(WSAStartup(MAKEWORD(2, 1), (LPWSADATA)&WSAData) != 0)
return;
gethostname(name, 100);
test = gethostbyname(name);
test->h_addrtype = test->h_addrtype;
for (i = 0; i < MAX_NET_NUM; i++)
{
addr = (struct in_addr *)test->h_addr_list[i];
if(addr == NULL)
break;
inaddr = *((in_addr *)test->h_addr_list[i]);
HostIpAddr.AllIpAddr[i] = ntohl(inaddr.S_un.S_addr);
if(IN_CLASSA(HostIpAddr.AllIpAddr[i])) /*A类地址*/
{
HostIpAddr.NetMaskIpAddr[i] = IN_CLASSA_NET;
HostIpAddr.MainIpAddr[i] = (HostIpAddr.AllIpAddr[i] & IN_CLASSA_NET);
HostIpAddr.BroadCastIpAddr[i] = (HostIpAddr.AllIpAddr[i] & IN_CLASSA_NET) | IN_CLASSA_HOST;
}
else if(IN_CLASSB(HostIpAddr.AllIpAddr[i])) /*B类地址*/
{
HostIpAddr.NetMaskIpAddr[i] = IN_CLASSB_NET;
HostIpAddr.MainIpAddr[i] = (HostIpAddr.AllIpAddr[i] & IN_CLASSB_NET);
HostIpAddr.BroadCastIpAddr[i] = (HostIpAddr.AllIpAddr[i] & IN_CLASSB_NET) | IN_CLASSB_HOST;
}
else if(IN_CLASSC(HostIpAddr.AllIpAddr[i])) /*C类地址*/
{
HostIpAddr.NetMaskIpAddr[i] = IN_CLASSC_NET;
HostIpAddr.MainIpAddr[i] = (HostIpAddr.AllIpAddr[i] & IN_CLASSC_NET);
HostIpAddr.BroadCastIpAddr[i] = (HostIpAddr.AllIpAddr[i] & IN_CLASSC_NET) | IN_CLASSC_HOST;
}
}
}
//创建用于系统配置的UDP socket
void CreatUdpSetSock(void)
{
int tmp;
char szConfig[256];
//GetCurrentDirectory(sizeof(szDir), szDir);
sprintf(szConfig, "%s/config.ini", IniFilePath);
if(UdpParamInitFlag == 0)
{
memset((char*)&UdpParam, 0, sizeof(UDP_SET_DEF));
UdpParam.PortNumber = GetPrivateProInt("NetCommPort", "UdpCommPort", 0, szConfig);
if(UdpParam.PortNumber == 0)
{
UdpParam.PortNumber = DEFAULT_UDP_COMM_PORT;
}
GetHostIpAddr();
UdpParamInitFlag = 1;
}
if(UdpParam.Socket)
return;
UdpParam.Socket = socket(AF_INET, SOCK_DGRAM, 0);
if(UdpParam.Socket <= 0)
{
UdpParam.Socket = 0;
return;
}
// wen 2005.12.01 在这里初始化数据
InitGlobalMember();
//设置socket输入输出绶冲
tmp = MAX_NET_BUF_SIZE;
setsockopt(UdpParam.Socket, SOL_SOCKET, SO_RCVBUF, (char*)&tmp, sizeof(tmp));
tmp = MAX_NET_BUF_SIZE;
setsockopt(UdpParam.Socket, SOL_SOCKET, SO_SNDBUF, (char*)&tmp, sizeof(tmp));
tmp = 1;
setsockopt(UdpParam.Socket, SOL_SOCKET, SO_BROADCAST, (char*)&tmp, sizeof(tmp)); // 广播
//让配置socket 能收不同网段的配置命令
memset(&UdpParam.Addr, 0, sizeof(UdpParam.Addr));
UdpParam.Addr.sin_family = AF_INET;
UdpParam.Addr.sin_port = htons(UdpParam.PortNumber);
// wen 2005.03.08 修改ip为指定的地址
UdpParam.Addr.sin_addr.s_addr = htonl(INADDR_ANY);
//UdpParam.Addr.sin_addr.s_addr = inet_addr("192.168.1.200");
if(bind(UdpParam.Socket, (struct sockaddr *)&UdpParam.Addr, sizeof(UdpParam.Addr)) < 0)
{
// windows
//DWORD dwerror = GetLastError();
closesocket(UdpParam.Socket);
UdpParam.Socket = 0;
}
}
void CloseUdpSetSock(void)
{
if(UdpParam.Socket)
{
closesocket(UdpParam.Socket);
}
UdpParam.Socket = 0;
}
int CheckIsMySelftIpAddr(u_long addr)
{
int i;
for(i = 0; i < MAX_NET_NUM; i++)
{
if(addr == HostIpAddr.AllIpAddr[i])
{
return true;
}
}
// 定义前置机功能
#ifdef FUNCTION_FEND
#if (FEND_OTHERDEV_DS3116 == 0)
// 非ds-3116设备时，需要用他来确定是否为另一个前置机
return CheckIsFendIpAddr(addr);
#endif
#endif
return false;
}
int CheckIsCurDevIpAddr(u_long addr)
{
//int i;
//for(i = 0; i < MAX_NET_NUM; i++)
{
if(addr == DevParam[iCurDevIdx].CurCommIp)
{
return true;
}
}
return false;
}
//接收网络配置网络命令
void SetUdpRecv(void)
{
struct timeval outtime;
int len;
int addr_len = sizeof(struct sockaddr_in);
fd_set set;
u_char recvbuf[MAX_NET_BUF_SIZE];
//char szDbg[128];
CreatUdpSetSock();
if(UdpParam.Socket == 0)
return;
memset((char*)&outtime, 0, sizeof(struct timeval));
memset((char*)&UdpParam.Addr, 0, sizeof(UdpParam.Addr));
FD_ZERO(&set);
FD_SET(UdpParam.Socket, &set);
for(; ;)
{
//异步收
if(select(FD_SETSIZE, &set, NULL, NULL, &outtime) < 1)
break;
len = recvfrom(UdpParam.Socket, (char*)recvbuf, MAX_NET_BUF_SIZE,0, (struct sockaddr *)&UdpParam.Addr, &addr_len) ;
if(len < 1)
break;
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// wen 2005.09.28 增加对udp通讯端口的显示
if(RealDataDispFlag)
{
if((CurPort == GetMaxPort()) && (CheckIsCurDevIpAddr(ntohl(UdpParam.Addr.sin_addr.s_addr))))
{
RTUMSG *msg;
WORD wLen, wType;
BYTE *ptr;
msg = (RTUMSG *)recvbuf;
if(IsNetSequence() == TRUE)
{
wType = msg->MsgType;
wLen = msg->MsgLen;
}
else
{
ptr = (BYTE *)&msg->MsgType;
wType = ptr[0] * 256 + ptr[1];
ptr = (BYTE *)&msg->MsgLen;
wLen = ptr[0] * 256 + ptr[1];
}
WatchDataPutDispBuf(msg->PortIdx, SDS_SIO_RECV_DATA, msg->MsgData, wLen);
}
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
if(CheckIsMySelftIpAddr(ntohl(UdpParam.Addr.sin_addr.s_addr)) == false)
{
/*
if(UdpParam.Addr.sin_addr.S_un.S_addr != 0xd802a8c0)
{
sprintf(szDbg, "IP(recv): %d.%d.%d.%d:%d",
UdpParam.Addr.sin_addr.S_un.S_un_b.s_b1,
UdpParam.Addr.sin_addr.S_un.S_un_b.s_b2,
UdpParam.Addr.sin_addr.S_un.S_un_b.s_b3,
UdpParam.Addr.sin_addr.S_un.S_un_b.s_b4,
UdpParam.Addr.sin_port);
DebugPrint(szDbg);
}
*/
void SetUdpRecvDataProcess(u_long ipaddr, u_char *buf, int len);
SetUdpRecvDataProcess(ntohl(UdpParam.Addr.sin_addr.s_addr), recvbuf, len);
}
//else
//{
// DebugPrint("Recv self.");
//}
}
}
//发送配置命令，引入IP地址，可以自由采用点对点，全网广播发送方式
int SetUdpSend(u_long ipaddr, char *buf, int len)
{
struct sockaddr_in addr;
int slen;
if(UdpParam.Socket == 0)
{
return false;
}
// 定义前置机功能
#ifdef FUNCTION_FEND
// wen 2005.10.12 增加是否下发前置机的判断
#if (FEND_OTHERDEV_DS3116 == 0)
if(GetFendTxdFlag() == 0)
{
return false;
}
#endif
#endif
if(len == 0)
{
return false;
}
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(UdpParam.PortNumber);
addr.sin_addr.s_addr = ntohl(ipaddr);
slen = sendto(UdpParam.Socket, buf, len, 0,
(struct sockaddr *)&addr, sizeof(struct sockaddr_in));
if(slen != len)
{
closesocket(UdpParam.Socket);
UdpParam.Socket = 0;
return false;
}
else
{
RTUMSG *msg;
WORD wLen, wType;
BYTE *ptr;
wLen = 0x55AA;
ptr = (BYTE *)&wLen;
msg = (RTUMSG *)buf;
if(ptr[0] == 0x55)
{
wType = msg->MsgType;
wLen = msg->MsgLen;
}
else
{
ptr = (BYTE *)&msg->MsgType;
wType = ptr[0] * 256 + ptr[1];
ptr = (BYTE *)&msg->MsgLen;
wLen = ptr[0] * 256 + ptr[1];
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// wen 2005.09.28 增加对udp通讯端口的显示
/*if((CurPort == msg->PortIdx) && RealDataDispFlag)
{
if(SDS_SIO_SEND_DATA == wType)
{
WatchDataPutDispBuf(msg->PortIdx, SDS_SIO_SEND_DATA, msg->MsgData, wLen);
}
}*/
if(RealDataDispFlag)
{
if(CurPort == msg->PortIdx)
{
if(SDS_SIO_SEND_DATA == wType)
{
WatchDataPutDispBuf(msg->PortIdx, SDS_SIO_SEND_DATA, msg->MsgData, wLen);
}
}
else if(CurPort == GetMaxPort())
{
WatchDataPutDispBuf(msg->PortIdx, SDS_SIO_SEND_DATA, msg->MsgData, wLen);
}
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
}
return true;
}
//填充配置结果，返包到上行绶冲
int FillAndSendCmd(u_long ipaddr, u_char port, WORD cmd, u_char *retbuf, int len)
{
RTUMSG rtumsg;
u_char *ptr;
int tmp = 0;
rtumsg.PortIdx = port;
ptr = (u_char*)&rtumsg.MsgType;
ptr[0] = HIBYTE(cmd);
ptr[1] = LOBYTE(cmd);
ptr[2] = HIBYTE(len);
ptr[3] = LOBYTE(len);
if(len)
memmove((char *)rtumsg.MsgData, retbuf, len);
if(ipaddr)
tmp = SetUdpSend(ipaddr, (char*)&rtumsg, sizeof(RTUMSGHEAD) + len);
else
{
if(DevParam[iCurDevIdx].CurCommIp)
tmp = SetUdpSend(DevParam[iCurDevIdx].CurCommIp, (char*)&rtumsg, sizeof(RTUMSGHEAD) + len);
}
return tmp;
}
int GetSdsIpAddr(void)
{
/*SYSTEMTIME sm;
char szInfo[128];
GetLocalTime(&sm);
sprintf(szInfo, "%02d_%02d:%02d:%02d.%03d GetSdsIpAddr\n",
sm.wDay, sm.wHour, sm.wMinute, sm.wSecond, sm.wMilliseconds);
OutputDebugString(szInfo);*/
return FillAndSendCmd(INADDR_BROADCAST, 0, SDS_N_GET_IP_ADDR, NULL, 0);
}
void ValueToBuf(u_char *buf, u_long val, int len)
{
switch(len)
{
case 2:
buf[0] = HIBYTE(LOWORD(val));
buf[1] = LOBYTE(LOWORD(val));
break;
case 4:
buf[0] = HIBYTE(HIWORD(val));
buf[1] = LOBYTE(HIWORD(val));
buf[2] = HIBYTE(LOWORD(val));
buf[3] = LOBYTE(LOWORD(val));
break;
}
}
u_long BufToValue(u_char *buf, int len)
{
u_long retv;
switch(len)
{
case 2:
retv = BYTE1(buf[0]) + BYTE0(buf[1]);
break;
case 4:
retv = BYTE3(buf[0]) + BYTE2(buf[1]) + BYTE1(buf[2]) + BYTE0(buf[3]);
break;
}
return retv;
}
void AddDispLine(DISP_LINE_BUF *dispbuf, char *msg)
{
char szbuf[128], tmp[128];
int k;
k = strlen(msg);
if(k == 0)
return;
if(k > 120)
msg[120] = 0;
k = 120 - strlen(msg);
strcpy(szbuf, msg);
if(k > 0)
{
memset(tmp, ' ', 120);
tmp[k] = 0;
strcat(szbuf, tmp);
}
strcpy(dispbuf->Line[dispbuf->Rear], szbuf);
dispbuf->Rear = (dispbuf->Rear + 1) % MAX_DISP_LINE;
// 当缓冲区满后, 丢掉前半个缓冲区内数据，否则，
// 我们无法停下来观看已有数据，它可能一直滚动,
// 因为每添加一行我们的指针不得不退让一行
dispbuf->LineCnt = dispbuf->LineCnt + 1;
if(dispbuf->LineCnt == MAX_DISP_LINE)
{
dispbuf->LineCnt -= MAX_DISP_LINE / 2;
}
}
void WatchDataPutDispBuf(int port, WORD type, u_char *buf, int len)
{
int i, j, k, linechar;
char szbuf[256], tmp[256], tchar;
SYSTEMTIME st;
if(giRealDataToFile == 1)
{
WatchDataPutDispBufToFile(port, type, buf, len);
return;
}
linechar = 18;
tchar = type == SDS_SIO_SEND_DATA ? 'S' : 'R';
GetLocalTime(&st);
szbuf[0] = tchar;
sprintf((char*)&szbuf[1], "%04d-%02d-%02d %02d:%02d:%02d.%03d 端口%d %s 数据, 长度 = %d",
st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond, st.wMilliseconds,
port + 1, type == SDS_SIO_SEND_DATA ? "发送" : "接收", len);
AddDispLine(&DevParam[iCurDevIdx].WatchDispLine, szbuf);
for (i = 0; i < len; i += linechar)
{
szbuf[0] = tchar;
sprintf((char*)&szbuf[1], "%04d: ", i);
k = min(linechar, len - i);
for (j = 0; j < k; j++)
{
sprintf(tmp, "%02X ", buf[i+j]);
strcat(szbuf, tmp);
if(((j + 1) % 6) == 0)
strcat(szbuf, " ");
}
AddDispLine(&DevParam[iCurDevIdx].WatchDispLine, szbuf);
}
sprintf(szbuf, "%c", tchar);
strcat(szbuf, " ");
AddDispLine(&DevParam[iCurDevIdx].WatchDispLine, szbuf);
}
void WatchDataPutDispBufToFile(int port, WORD type, u_char *buf, int len)
{
int i, j, k, linechar;
char szbuf[256], tmp[256], tchar;
char szFileName[256];
FILE *fp;
SYSTEMTIME st;
linechar = 18;
tchar = type == SDS_SIO_SEND_DATA ? 'S' : 'R';
GetLocalTime(&st);
//getcwd(szFileName, sizeof(szFileName));
sprintf(szFileName, "%s\\log\\realdata%02d.txt", IniFilePath, port+1);
fp = fopen(szFileName, "a");
szbuf[0] = tchar;
sprintf((char*)&szbuf[1], "%04d-%02d-%02d %02d:%02d:%02d.%03d 端口%d %s 数据, 长度 = %d",
st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond, st.wMilliseconds,
port + 1, type == SDS_SIO_SEND_DATA ? "发送" : "接收", len);
AddDispLine(&DevParam[iCurDevIdx].WatchDispLine, szbuf);
if(fp)
{
strcat(szbuf, "\n");
fwrite(szbuf, sizeof(char), strlen(szbuf), fp);
}
for (i = 0; i < len; i += linechar)
{
szbuf[0] = tchar;
sprintf((char*)&szbuf[1], "%04d: ", i);
k = min(linechar, len - i);
for (j = 0; j < k; j++)
{
sprintf(tmp, "%02X ", buf[i+j]);
strcat(szbuf, tmp);
if(((j + 1) % 6) == 0)
strcat(szbuf, " ");
}
AddDispLine(&DevParam[iCurDevIdx].WatchDispLine, szbuf);
if(fp)
{
strcat(szbuf, "\n");
fwrite(szbuf, sizeof(char), strlen(szbuf), fp);
}
}
sprintf(szbuf, "%c", tchar);
strcat(szbuf, " ");
AddDispLine(&DevParam[iCurDevIdx].WatchDispLine, szbuf);
if(fp)
{
strcpy(szbuf, " \n");
fwrite(szbuf, sizeof(char), strlen(szbuf), fp);
fclose(fp);
}
}
int FindDev( u_long ipaddr )
{
int i, j;
for ( i = 0; i < iDevNum; i++ )
{
for( j = 0; j < MAX_NET_NUM; j++ )
{
if ( DevParam[i].IpAddr[j] == 0 )
continue;
if ( DevParam[i].IpAddr[j] == ipaddr )
return i;
}
}
return -1;
}
int AddDev( u_long *addr, int num )
{
int i, dev;
for ( i = 0; i < num; i++ )
{
if ( addr[i] )
{
dev = FindDev( addr[i] );
if ( dev >= 0 )
return dev;
}
}
// 新设备
iDevNum++;
return iDevNum - 1;
}
void SetUdpRecvDataProcess(u_long ipaddr, u_char *buf, int len)
{
RTUMSG *msg;
int plen, i, k, dev, net;
u_long addr[MAX_NET_NUM];
WORD tmp;
char *ptr;
//char szInfo[256];
for(plen = 0; plen < len;)
{
msg = (RTUMSG*)&buf[plen];
//让数值为高字节前，低字节后(但此处无特别的作用，仅为了与机器无关而设)
tmp = BYTE1(buf[plen+1]) + BYTE0(buf[plen+2]);
msg->MsgType = tmp;
tmp = BYTE1(buf[plen+3]) + BYTE0(buf[plen+4]);
msg->MsgLen = tmp;
plen += (msg->MsgLen + sizeof(RTUMSGHEAD));
//if(!(msg->MsgType & 0x8000))
//{
// continue;
//}
switch(msg->MsgType & 0x3fff)
{
// 获取系统IP到上行
// 0x00 - 0x03字节: 第一网卡地址IP地址
// 0x044 - 0x07字节: 第二网卡地址IP地址
// 0x08字节： 端口数目总数，包括网络通讯端口
// 0x09 - 0xd字节： 保留
// 0x0e字节： 串行通讯端口数目
// 0x0f字节： 网络通讯端口数目
// 0x10 - 4个带0x00结尾的字符串，它们是设备名称、软件版本、
// 软件版本日期和制造厂商名称
// 接下来，如果网卡数量多于2个，接着填写从第三网卡
// 开始的网络IP地址
case SDS_GET_IP_ADDR:
case SDS_N_GET_IP_ADDR:
if(!(msg->MsgType & 0x8000))
{
break;
}
for (i = 0; i < 2; i++)
{
addr[i] = BYTE3(msg->MsgData[i*4+0])
+ BYTE2(msg->MsgData[i*4+1])
+ BYTE1(msg->MsgData[i*4+2])
+ BYTE0(msg->MsgData[i*4+3]);
/*sprintf(szInfo, "NET%d: %d.%d.%d.%d\n",
i+1, msg->MsgData[i*4+0],
msg->MsgData[i*4+1],
msg->MsgData[i*4+2],
msg->MsgData[i*4+3]);
OutputDebugString(szInfo);*/
}
// 跳过4个字符串
k = 0x10;
ptr = (char*)&msg->MsgData[k];
k += (strlen(ptr) + 1);
ptr = (char*)&msg->MsgData[k];
k += (strlen(ptr) + 1);
ptr = (char*)&msg->MsgData[k];
k += (strlen(ptr) + 1);
ptr = (char*)&msg->MsgData[k];
k += (strlen(ptr) + 1);
net = (msg->MsgLen - k) / 4;
if((net + 2) > MAX_NET_NUM)
{
break;
}
for (i = 0; i < net; i++)
{
addr[2+i] = BYTE3(msg->MsgData[k+0])
+ BYTE2(msg->MsgData[k+1])
+ BYTE1(msg->MsgData[k+2])
+ BYTE0(msg->MsgData[k+3]);
/*sprintf(szInfo, "NET%d: %d.%d.%d.%d\n",
i+3, msg->MsgData[k+0],
msg->MsgData[k+1],
msg->MsgData[k+2],
msg->MsgData[k+3]);
OutputDebugString(szInfo);*/
k += 4;
}
net += 2;
dev = AddDev(&addr[0], net);
DevParam[dev].CurCommIp = ipaddr;
for (i = 0; i < MAX_NET_NUM; i++)
{
if(i < net)
{
if(DevParam[dev].IpAddr[i])
{
if(DevParam[dev].IpAddr[i] != addr[i])
DevParam[dev].IpAddrChangeFlag = 1;
}
DevParam[dev].IpAddr[i] = addr[i];
}
else
DevParam[dev].IpAddr[i] = 0;
}
DevParam[dev].NetNum = net;
DevParam[dev].PortNum = msg->MsgData[8];
DevParam[dev].SerialPortNum = msg->MsgData[0x0e];
DevParam[dev].NetPortNum = msg->MsgData[0x0f];
break;
case SDS_SIO_SET_CONFIG_FILE:
if(!(msg->MsgType & 0x8000))
{
break;
}
//dev = FindDev(ipaddr);
//if (dev < 0)
// break;
//ClrWaitFlag(dev);
tmp = BYTE1(msg->MsgData[0]) + BYTE0(msg->MsgData[1]);
// 传输错误, 重来
if((msg->MsgType & 0xc000) == 0x4000)
{
tmp = 0;
}
SetDevConfigFile(tmp + 1);
break;
case SDS_SIO_RECV_DATA:
if(!CheckIsCurDevIpAddr(ipaddr))
{
break;
}
if(FunCallPtr[SioParam[msg->PortIdx].ProtocolIdx].RecvData)
{
FunCallPtr[SioParam[msg->PortIdx].ProtocolIdx].RecvData(msg->PortIdx,
msg->MsgData, msg->MsgLen);
//SioParam[msg->PortIdx].RecvCharNum += msg->MsgLen;
}
// wen 2004.11.25 删除数据缓冲区数据长度(保持和5249中的程序一致)
SioParam[msg->PortIdx].RecvBuf.MsgCnt = 0;
SioParam[msg->PortIdx].RecvCharNum += msg->MsgLen;
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// wen 2006.04.24 如果仅仅是接收到数据，不认为端口状态为正常，
// 必须是修改了数据库点才认为是端口正常。子站除外。
//SioParam[msg->PortIdx].LineCommCnt = 0;
//SioParam[msg->PortIdx].Status = TRUE;
//=============================================================
SioParam[msg->PortIdx].LineCommCnt = 0;
if(SioParam[msg->PortIdx].m_psBaoHu)
{
// 如果为子站
if(SioParam[msg->PortIdx].m_psBaoHu->PortType)
{
SioParam[msg->PortIdx].Status = TRUE;
}
}
else
{
SioParam[msg->PortIdx].Status = TRUE;
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//if((CurPort == msg->PortIdx) && RealDataDispFlag)
//{
// WatchDataPutDispBuf(msg->PortIdx, SDS_SIO_RECV_DATA, msg->MsgData, msg->MsgLen);
//}
break;
case SDS_SIO_SEND_DATA:
// 数据已经接收
//sprintf(szInfo, "TIP_(%08d): port=%d Send Data is received.\n",
// getpid(), msg->PortIdx+1);
//DebugPrint(szInfo);
break;
default:
//sprintf(szInfo, "ERR_(%08d): port=%d Recv Error(Func=%d).",
// getpid(), msg->PortIdx+1, msg->MsgType);
//DebugPrint(szInfo);
break;
}
}
}
void SetDevConfigFile(int blk)
{
if(SetDevConfigFileEx(gCurConfigFileName, blk) != 0)
{
//((CWidgetMainWnd *)qApp->mainWidget())->RestoreCursor();
}
}
int SetDevConfigFileEx(char *szPortConfigName, int blk)
{
char szbuf[1024];
int idx, blklen, iSendLen;
FILE *fp;
if(!DevParam[iCurDevIdx].CurCommIp)
{
////QTMessageBox("设备配置文件...", "无有效设备!!!");
return -1;
}
if(szPortConfigName == NULL)
{
//QTMessageBox("设备配置文件...", "下装设备配置文件名称错误!!!");
return -1;
}
if(strlen(szPortConfigName) == 0)
{
//QTMessageBox("设备配置文件...", "下装设备配置文件名称错误!!!");
return -1;
}
// wen 2005.12.01 在这里设置全局的配置文件名称
if(blk == 0)
{
strcpy(gCurConfigFileName, szPortConfigName);
}
fp = fopen(szPortConfigName, "rb");
if(fp == NULL)
{
return -1;
}
for(idx = 0; ; idx++)
{
blklen = fread((char*)&szbuf[2], 1, BLK_SIZE, fp);
if(blklen < 1)
{
break;
}
if(idx == blk)
{
szbuf[0] = HIBYTE(blk);
szbuf[1] = LOBYTE(blk);
iSendLen = FillAndSendCmd(0, 0, SDS_SIO_SET_CONFIG_FILE, (u_char*)szbuf, blklen + 2);
fclose(fp);
if(iSendLen == 0)
{
//QTMessageBox("设备配置文件...", "下装设备配置文件失败!!!");
return -1;
}
return 0;
}
}
fclose(fp);
//MessageBox(NULL, "设备配置文件设置完成!!!", "设备配置文件...", MB_OK | MB_ICONINFORMATION);
//QTMessageBox("设备配置文件...", "设备配置文件设置完成!!!");
return 1;
}
void SetDevTime()
{
BYTE buf[16];
DAY_TIME sm;
GetLocalTimeEx(&sm);
buf[0] = HIBYTE(sm.Year);
buf[1] = LOBYTE(sm.Year);
buf[2] = 0;
buf[3] = sm.Month;
buf[4] = 0;
buf[5] = sm.Day;
buf[6] = 0;
buf[7] = sm.Hour;
buf[8] = 0;
buf[9] = sm.Min;
buf[10] = 0;
buf[11] = sm.Sec;
FillAndSendCmd(INADDR_BROADCAST, 0, SDS_SIO_SET_SYSTEM_TIME, buf, 12);
}
void ResetDev(int iDevNo)
{
if(iDevNo >= 0)
{
FillAndSendCmd(DevParam[iDevNo].CurCommIp, 0, SDS_SIO_RESET, NULL, 0);
}
else
{
FillAndSendCmd(0, 0, SDS_SIO_RESET, NULL, 0);
}
}
BOOL isUdpSocketExist()
{
if(UdpParam.Socket)
{
return TRUE;
}
else
{
return FALSE;
}
}

38
udpcomm.h
Unescape Escape View File

@ -0,0 +1,38 @@
#ifndef __UDP_COMM_H_ICL__
#define __UDP_COMM_H_ICL__
#include "common.h"
//#include "resource.h"
void InitGlobalMember();
void GetHostIpAddr( void );
int GetSdsIpAddr( void );
void CreatUdpSetSock( void );
void CloseUdpSetSock( void );
int CheckIsMySelftIpAddr( u_long addr );
void SetUdpRecv( void );
int SetUdpSend( u_long ipaddr, char *buf, int len );
int FillAndSendCmd( u_long ipaddr, u_char port, WORD cmd, u_char *retbuf, int len );
void ValueToBuf( u_char *buf, u_long val, int len );
u_long BufToValue( u_char *buf, int len );
void WatchDataPutDispBuf( int port, WORD type, u_char *buf, int len );
void WatchDataPutDispBufToFile(int port, WORD type, u_char *buf, int len);
void SetUdpRecvDataProcess( u_long ipaddr, u_char *buf, int len );
void SetDevConfigFile(int blk);
int SetDevConfigFileEx(char *szPortConfigName, int blk);
void SetDevTime();
void ResetDev(int iDevNo);
BOOL isUdpSocketExist();
#endif

1027
udpping.cpp
View File

File diff suppressed because it is too large Load Diff

109
udpping.h
Unescape Escape View File

@ -0,0 +1,109 @@
/************************************************************************************
*
* Copyright (C) 2002-2003 SCADA Control Technology Co., Ltd. All rights reserved.
*
* $Source: /opt/CVS_ROOT_PGC_EX2000/commserver/windows/widgets/udpping.h,v $
*
* $Author: jehu $
*
* $Date: 2006/07/05 07:31:44 $
*
* $Revision: 1.1.1.1 $
*
* $State: Exp $
*
* $Name: $
*
* $Locker: $
*
* $Log: udpping.h,v $
* Revision 1.1.1.1 2006/07/05 07:31:44 jehu
* no message
*
* Revision 1.4 2006/04/28 06:29:18 administrator
* 修改ping数据包为点对点发送
*
* Revision 1.3 2006/04/22 07:51:07 administrator
* 竞争时间用宏代替
*
* Revision 1.2 2005/10/20 07:03:56 Administrator
* 前置机功能完善
*
* Revision 1.1 2005/10/12 06:03:47 Administrator
* 增加前置机功能
*
*
* 添加CVS关键字,每次提交自动更新；
*
**************************************************************************************/
//***************************************************************
//* udpcomm.h *
//* Liangchu Lee 2000.07.10 *
//***************************************************************
#ifndef __UDPPING_H_ICL__
#define __UDPPING_H_ICL__
#include "common.h"
#define MAX_DELAYTIME 20
#define MAX_RANDOM 32
#define MAX_NODENAME 64
#define PINGRANDOM ("!L$Q_TO5U^8&J @T#H*F(J)+D%RG|<>T~?:{}AESRGA")
typedef struct tagUDP_PING_INFO
{
SOCKET rSocket __attribute__ ((packed));
SOCKET sSocket[MAX_ADDR] __attribute__ ((packed));
struct sockaddr_in SerAddr __attribute__ ((packed));
struct sockaddr_in CliAddr __attribute__ ((packed));
} UDP_PING_INFO;
typedef struct tagUDP_PING_REV_DATA
{
int MsgLen __attribute__ ((packed));
char MsgData[MAX_NET_BUF] __attribute__ ((packed));
} UDP_PING_REV_DATA;
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// 是pc机系统还是嵌入式系统
#ifdef PC_MACHINE
#ifdef OS_WINDOWS
#pragma pack (push,1)
#else// OS_UNIX
#pragma pack(1)
#endif //OS_UNIX
#endif
typedef struct tagPINGINFORMATION
{
BYTE barrRandom[MAX_RANDOM] __attribute__ ((packed));
char szNodeName[MAX_NODENAME] __attribute__ ((packed));
BYTE bNodeType __attribute__ ((packed)); /*节点类型*/
WORD wNodeID __attribute__ ((packed)); /*接点号*/
u_long inetMask __attribute__ ((packed)); /*网络掩码, 发送者, 主机字节顺序*/
u_long inetAddr __attribute__ ((packed)); /*完整IP地址, 发送者, 主机字节顺序*/
DWORD dwStatus __attribute__ ((packed)); /*该网络接口IP地址的状态*/
} PINGINFORMATION;
// 是pc机系统还是嵌入式系统
#ifdef PC_MACHINE
#ifdef OS_WINDOWS
#pragma pack (pop)
#else// OS_UNIX
#pragma pack (0)
#endif //OS_UNIX
#endif
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void UdpPingTimer(void);
BOOL UdpPingInit(void);
void UdpPingSendData(void);
void UdpPingSendDataP2P(void);
void UdpPingReaddata(void);
void UdpPingClose(void);
//
void UdpPingSwitch(void);
#endif

153
widgets.cpp
Unescape Escape View File

@ -0,0 +1,153 @@
// widgets.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#define OS_WINDOWS 0
#include <iostream>
#include "baohua.h"
#include "buban103.h"
#include "buban104.h"
#include "scadaprotect.h"
// 网络端口数据，范围为 0 - 16
#define NET_PORT_NUM 8
extern const char *gpStrBuban103ConfigInfo[];
extern const char *gpStrBuban104ConfigInfo[];
extern const char *gpStrScadaProtectConfigInfo[];
u_char Bit_8_Mask[8] = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 };
BYTE SyncWordEB[6] = { 0xeb, 0x90, 0xeb, 0x90, 0xeb, 0x90 };
BYTE SyncWordD7[6] = { 0xd7, 0x09, 0xd7, 0x09, 0xd7, 0x09 };
FUNCTION_CALL FunctionCall[] =
{
// 配置一空协议, 主要用于处理协议序列为零的情况, 如零初始值等
{(char*)"none", (char*)"none", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL},
// 旁路协议，用于在上位机调试规约程序
{(char*)"bypass", (char*)"bypass", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL},
// BUBAN103规约
{(char*)"BUBAN103", (char*)"BUBAN103 protocol", NULL, Buban103ReadConfig,\
Buban103RecvData, Buban103Timer, Buban103YkYtProcess, Buban103SendSystemTime,\
Buban103Exit, Buban103BaoHuCmdProcess, Buban103GetBaohuDataBase},
// BUBAN104规约
{(char*)"BUBAN104", (char*)"BUBAN104 protocol", NULL, Buban104ReadConfig,\
Buban104RecvData, Buban104Timer, Buban104YkYtProcess, Buban104SendSystemTime,\
Buban104Exit, Buban104BaoHuCmdProcess, Buban104GetBaohuDataBase},
// SCADAPROTECT规约
{(char*)"SCADAPROTECT", (char*)"SCADA INSIDE", NULL, ScadaProtectReadConfig,\
ScadaProtectRecvData, ScadaProtectTimer, ScadaProtectYkYtProcess, NULL,\
ScadaProtectExit, ScadaProtectBaoHuCmdProcess, ScadaProtectGetBaohuDataBase},
// 添加协议名称及处理程序入口等
{(char*)" ", (char*)" ", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL} // 结束标志
};
int InitBaohuMainFlag = 0;
//int testcnt = 0;
//char testbuf[] = "1234567890";
void BaohuLibMain(int netportnum);
int main(void)
{
std::cout << "Hello World!\n";
int ret = SUCCESS;
char filename[256];
WSADATA WSAData;
//定时器指针置空
//m_pMainTimer = NULL;
//该段代码进入环境变量KERNELFEND_ROOT所指定的目录
char* envBuf;
envBuf = getenv("CAC_ROOT");
if (envBuf != NULL) //如果取得环境变量，则使用其所指定的目录
{
sprintf(IniFilePath, "%s/ini", envBuf);
}
else //如果未取得环境变量，则使用当前工作目录
{
_getcwd(IniFilePath, sizeof(IniFilePath));
}
//清空数据文件名
memset((void*)pvDataFileName, 0, sizeof(pvDataFileName));
//采用哈希表读配置文件config.ini modified by jessie in 20060729
sprintf(filename, "%s/config.ini", IniFilePath);
ret = conf_open(filename, &pvconf_handle);
if (SUCCESS != ret)
{
printf("WARN(%04d): load config.ini is failed\n", _getpid());
return -1;
}
//采用哈希表读配置文件portconfig.ini modified by jessie in 20060729
sprintf(filename, "%s/portconfig.ini", IniFilePath);
ret = conf_open(filename, &pvportconf_handle);
if (SUCCESS != ret)
{
printf("WARN(%04d): load portconfig.ini is failed\n", _getpid());
return -1;
}
// 初始化数据屏设置数据库指针
if (InitBaohuMainFlag == 0)
{
FunCallPtr = &FunctionCall[0];
strcpy(DeviceName, DEVIVE_NAME);
strcpy(Version, VERSION);
strcpy(VersionDate, VERSION_DATE);
strcpy(Manufacturer, MANUFACTURER);
InitBaohuMainFlag = 1;
if (WSAStartup(MAKEWORD(2, 1), (LPWSADATA)&WSAData) != 0)
{
ret = WSAGetLastError();
//HostWSAStartupErr = TRUE;
//return FALSE;
}
}
// 测试程序，产生下发数据，正常是规约程序产生数据
// if ( testcnt != DayTime.Sec )
// {
// testcnt = DayTime.Sec;
// PutPollCmdToBuf( 0, NORMAL_CMD_TYPE, 0, testbuf, strlen(testbuf));
// }
for(;;)
BaohuLibMain(NET_PORT_NUM);
if (pvconf_handle != NULL)
{
conf_close(pvconf_handle);
pvconf_handle = NULL;
}
if (pvportconf_handle != NULL)
{
conf_close(pvportconf_handle);
pvportconf_handle = NULL;
}
if (pvdataconf_handle != NULL)
{
conf_close(pvdataconf_handle);
pvdataconf_handle = NULL;
}
}
// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单
// 入门使用技巧:
// 1. 使用解决方案资源管理器窗口添加/管理文件
// 2. 使用团队资源管理器窗口连接到源代码管理
// 3. 使用输出窗口查看生成输出和其他消息
// 4. 使用错误列表窗口查看错误
// 5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
// 6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件

211
widgets.vcxproj
Unescape Escape View File

@ -0,0 +1,211 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<VCProjectVersion>15.0</VCProjectVersion>
<ProjectGuid>{EEA43B07-32A7-4DE8-9E7F-20AE51E2C1A9}</ProjectGuid>
<Keyword>Win32Proj</Keyword>
<RootNamespace>widgets</RootNamespace>
<WindowsTargetPlatformVersion>10.0.17763.0</WindowsTargetPlatformVersion>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v141</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v141</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v141</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v141</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="Shared">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<LinkIncremental>true</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<LinkIncremental>true</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<LinkIncremental>false</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<LinkIncremental>false</LinkIncremental>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions);_CRT_SECURE_NO_WARNINGS;DISABLE_OS_HEAP</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<AdditionalOptions>/UTF-8 %(AdditionalOptions)</AdditionalOptions>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
<AdditionalDependencies>Ws2_32.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level3</WarningLevel>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level3</WarningLevel>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="basefunc.cpp" />
<ClCompile Include="buban103.cpp" />
<ClCompile Include="buban104.cpp" />
<ClCompile Include="chainlist.cpp" />
<ClCompile Include="commport.cpp" />
<ClCompile Include="conf_close.cpp" />
<ClCompile Include="conf_open.cpp" />
<ClCompile Include="conf_read_key.cpp" />
<ClCompile Include="conf_write_key.cpp" />
<ClCompile Include="display.cpp" />
<ClCompile Include="DSFileSystem.cpp" />
<ClCompile Include="Inifile.cpp" />
<ClCompile Include="list_entry.cpp" />
<ClCompile Include="netport.cpp" />
<ClCompile Include="os_heap.cpp" />
<ClCompile Include="Profile_Hash.cpp" />
<ClCompile Include="scadaprotect.cpp" />
<ClCompile Include="tcphost.cpp" />
<ClCompile Include="udpcomm.cpp" />
<ClCompile Include="udpping.cpp" />
<ClCompile Include="widgets.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="baohua.h" />
<ClInclude Include="basefunc.h" />
<ClInclude Include="basetype.h" />
<ClInclude Include="buban103.h" />
<ClInclude Include="buban104.h" />
<ClInclude Include="chainlist.h" />
<ClInclude Include="common.h" />
<ClInclude Include="commport.h" />
<ClInclude Include="confrw.h" />
<ClInclude Include="confrw_errno.h" />
<ClInclude Include="display.h" />
<ClInclude Include="DSFileSystem.h" />
<ClInclude Include="filesystemdialog.ui.h" />
<ClInclude Include="FileSystemDlgimpl.h" />
<ClInclude Include="global_errno.h" />
<ClInclude Include="Header.h" />
<ClInclude Include="inifile.h" />
<ClInclude Include="ListReport.h" />
<ClInclude Include="list_entry.h" />
<ClInclude Include="netport.h" />
<ClInclude Include="os_heap.h" />
<ClInclude Include="platform_def.h" />
<ClInclude Include="Profile_Hash.h" />
<ClInclude Include="scadaprotect.h" />
<ClInclude Include="tcphost.h" />
<ClInclude Include="udpcomm.h" />
<ClInclude Include="udpping.h" />
<ClInclude Include="_confrw.h" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

168
widgets.vcxproj.filters
Unescape Escape View File

@ -0,0 +1,168 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="源文件">
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
<Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
</Filter>
<Filter Include="头文件">
<UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
<Extensions>h;hh;hpp;hxx;hm;inl;inc;ipp;xsd</Extensions>
</Filter>
<Filter Include="资源文件">
<UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="widgets.cpp">
<Filter>源文件</Filter>
</ClCompile>
<ClCompile Include="buban103.cpp">
<Filter>源文件</Filter>
</ClCompile>
<ClCompile Include="buban104.cpp">
<Filter>源文件</Filter>
</ClCompile>
<ClCompile Include="commport.cpp">
<Filter>源文件</Filter>
</ClCompile>
<ClCompile Include="display.cpp">
<Filter>源文件</Filter>
</ClCompile>
<ClCompile Include="Inifile.cpp">
<Filter>源文件</Filter>
</ClCompile>
<ClCompile Include="scadaprotect.cpp">
<Filter>源文件</Filter>
</ClCompile>
<ClCompile Include="tcphost.cpp">
<Filter>源文件</Filter>
</ClCompile>
<ClCompile Include="udpcomm.cpp">
<Filter>源文件</Filter>
</ClCompile>
<ClCompile Include="udpping.cpp">
<Filter>源文件</Filter>
</ClCompile>
<ClCompile Include="basefunc.cpp">
<Filter>源文件</Filter>
</ClCompile>
<ClCompile Include="chainlist.cpp">
<Filter>源文件</Filter>
</ClCompile>
<ClCompile Include="DSFileSystem.cpp">
<Filter>源文件</Filter>
</ClCompile>
<ClCompile Include="os_heap.cpp">
<Filter>源文件</Filter>
</ClCompile>
<ClCompile Include="conf_read_key.cpp">
<Filter>源文件</Filter>
</ClCompile>
<ClCompile Include="conf_write_key.cpp">
<Filter>源文件</Filter>
</ClCompile>
<ClCompile Include="Profile_Hash.cpp">
<Filter>源文件</Filter>
</ClCompile>
<ClCompile Include="list_entry.cpp">
<Filter>源文件</Filter>
</ClCompile>
<ClCompile Include="conf_open.cpp">
<Filter>源文件</Filter>
</ClCompile>
<ClCompile Include="conf_close.cpp">
<Filter>源文件</Filter>
</ClCompile>
<ClCompile Include="netport.cpp">
<Filter>源文件</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="baohua.h">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="buban103.h">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="buban104.h">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="common.h">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="commport.h">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="display.h">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="filesystemdialog.ui.h">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="FileSystemDlgimpl.h">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="Header.h">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="inifile.h">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="ListReport.h">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="platform_def.h">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="scadaprotect.h">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="tcphost.h">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="udpcomm.h">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="udpping.h">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="basefunc.h">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="basetype.h">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="chainlist.h">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="DSFileSystem.h">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="os_heap.h">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="confrw.h">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="confrw_errno.h">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="global_errno.h">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="_confrw.h">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="Profile_Hash.h">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="list_entry.h">
<Filter>头文件</Filter>
</ClInclude>
<ClInclude Include="netport.h">
<Filter>头文件</Filter>
</ClInclude>
</ItemGroup>
</Project>

4
widgets.vcxproj.user
Unescape Escape View File

@ -0,0 +1,4 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup />
</Project>
Write Preview
Loading…
Cancel
Save