int
_executer_read_buffer (int sock, void *buf, size_t size)
{
size_t leido;
size_t left;
left = size;
leido = 0;
utils_trace ("Leyendo del buffer %i bytes...\n", size);
do
{
size_t leido2;
leido2 = read (sock, buf, left);
utils_trace ("Leido %i bytes...\n", leido2);
if (leido2 == 0)
{
return leido;
}
else if (leido2 < 0)
{
utils_error ("Error reading from socket: %s", strerror (errno));
return leido2;
}
leido += leido2;
left -= leido2;
}
while (leido < size);
return leido;
}
/*
when a PMC daemon is started, it first checks if there's
already a daemon running on the network with the same nodekey,
if yes, the newly started daemon automaticly runs in backup
mode until demanded to switch to primary mode.
*/
bool setup_running_state()
{
__uint items;
NODE_KEY nodeKey;
char buffer[8192];
string dirname;
*buffer = 0;
/*
running-state check must be done in backup mode.
*/
set_power_state(PWR_BACKUP);
host_to_node(&g_ThisNode->key, &nodeKey);
utils_trace("Finding primary site....\n");
items = discover_configfiles(&nodeKey, buffer, sizeof(buffer), 2000);
if(!items){
utils_trace("No primary site found, starting as primary.\n");
set_power_state(PWR_RUNNING);
}else{
if(!g_bAllowBackup){
utils_error(
"Primary site unexpected, "
"use '-2' command line option to force start as backup.\n"
);
return __false;
}
utils_trace("Primary site found, server will be started in backup mode.\n");
#if 0
__uint i, filesize;
char *item, *filebuf;
FILE *fp;
utils_trace("Primary site found, downloading configurations....\n");
item = buffer;
dirname = get_working_dir();
for(i=0; i<items && *item; i++){
utils_trace("Downloading file (%d of %d) %s....\n", i+1, items, item);
if(!download_file(&nodeKey, item, &filebuf, &filesize)){
utils_error("Unable to download '%s'\n", item);
return false;
}
fp = fopen((dirname + "/" + item).data(), "wb");
if(!fp){
utils_error("Unable to write to '%s'\n", item);
proxy_release_data(filebuf);
return false;
}
fwrite(filebuf, 1, filesize, fp);
fclose(fp);
proxy_release_data(filebuf);
item += strlen(item) + 1;
rtk_sleep(100);
}
#endif
}
return true;
}
static int _restart()
{
// report to the SCM that we're about to start
utils_trace("Re-starting PMC Serial Port Access Coordinator Version 1.0...\n");
uninit();
init();
utils_trace("PMC Serial Port Access Coordinator Version 1.0 re-started...\n");
return 1;
}
__bool _load_module(DRIVER_INFO & driver)
{
HINSTANCE h;
utils_trace("Loading IO driver %s\n", driver.dllname);
driver.flags &= ~DRIVER_FLAG_LOADED;
h = LoadLibrary(driver.dllname);
if( !h ){
strncat(driver.dllname, DLL_SUFFIX, sizeof(driver.dllname));
driver.dllname[ sizeof(driver.dllname) - 1] = 0;
h = LoadLibrary(driver.dllname);
}
if( !h ){
utils_error("Cannot load driver %s.\n", driver.dllname);
return __false;
}
driver.plugin_handle = (void*)h;
driver.flags |= DRIVER_FLAG_LOADED;
#define check_old(p) assert(!GetProcAddress(h, #p))
check_old(init);
check_old(start);
check_old(stop);
(FARPROC&)driver.load = GetProcAddress(h, "load");
(FARPROC&)driver.unload = GetProcAddress(h, "unload");
(FARPROC&)driver.start_device = GetProcAddress(h, "start_device");
(FARPROC&)driver.stop_device = GetProcAddress(h, "stop_device");
(FARPROC&)driver.address_translate = GetProcAddress(h, "address_translate");
(FARPROC&)driver.update_tag = GetProcAddress(h, "update_tag");
(FARPROC&)driver.write_device = GetProcAddress(h, "write_device");
(FARPROC&)driver.dispatch = GetProcAddress(h, "dispatch");
if(!driver.dispatch){
(FARPROC&)driver.dispatch = GetProcAddress(h, "_dispatch@12");
}
#ifdef _WIN32
get_file_version(driver.dllname, (PLARGE_INTEGER)&driver.version);
get_file_description(
driver.dllname,
driver.description,
sizeof(driver.description)
);
#else
//
#endif
utils_trace("IO driver %s loaded at 0x%08x\n", driver.dllname, driver.plugin_handle);
return __true;
}
// ignore parameters in this sample service
void CSpacService :: Run(DWORD, LPTSTR *) {
if (g_SingleInstanceObj.IsAnotherInstanceRunning()){
utils_error("Another PMCSpac Daemon instance is already running.\n");
return;
}
// report to the SCM that we're about to start
utils_trace("Starting PMC Serial Port Access Coordinator Version 1.0...\n");
ReportStatus(SERVICE_START_PENDING);
m_hStop = ::CreateEvent(0, FALSE, FALSE, 0);
SECURITY_ATTRIBUTES sd;
ZeroMemory(&sd, sizeof(sd));
sd.nLength = sizeof(sd);
m_hRestart = ::CreateEvent(&sd, FALSE, FALSE, SPAC_RESET_EVENT);
HANDLE handles[2];
handles[0] = m_hStop;
handles[1] = m_hRestart;
// You might do some more initialization here.
// Parameter processing for instance ...
utils_trace("PMC Serial Port Access Coordinator Version 1.0 started...\n");
init();
// enter main-loop
// If the Stop() method sets the event, then we will break out of
// this loop.
// report SERVICE_RUNNING immediately before you enter the main-loop
// DON'T FORGET THIS!
ReportStatus(SERVICE_RUNNING);
bool bStop = false;
while(!bStop){
switch(MsgWaitForMultipleObjects(2,handles,false,INFINITE,QS_ALLEVENTS) ){
case WAIT_OBJECT_0:
bStop = true;
break;
case WAIT_OBJECT_0 + 1:
_restart();
break;
case WAIT_OBJECT_0 + 2:
MSG msg;
while(PeekMessage(&msg,NULL,0,0,PM_REMOVE)){
TranslateMessage(&msg);
DispatchMessage(&msg);
break;
}
}
}
if( m_hStop ) ::CloseHandle(m_hStop);
uninit();
ReportStatus(SERVICE_STOPPED);
}
static int dumpDevices(FILE * of)
{
int i;
struct io_device * d;
devlib_ent_t * dd;
char configStr[128];
bool nullConfig;
d = ke_get_device_list(proxy_adapter->kernel);
for(i=0; i<IO_MAX_DEVICES; i++, d++){
if(!(d->features & IO_DEVICE_PRESENT)){
continue;
}
dd = blklib_get_dev_by_id(&d->clsid);
if(dd && !strcmpi(dd->name, "none")){
continue;
}
{
int j;
char * p;
p=configStr;
nullConfig=true;
for(j=0;j<DEV_CONFIG_LEN;j++){
p+=sprintf(p,"%02x", d->configData[j]);
if(d->configData[j]){
nullConfig=false;
}
}
}
if(dd){
if(of==stdout)
utils_trace("device %d %s %s\n", i, dd->name, nullConfig? "" : configStr);
else
fprintf(of, "device %d %s %s\n", i, dd->name, nullConfig? "" : configStr);
}else{
char uid[128];
f8_uuid_to_string(&d->clsid, uid, sizeof(uid));
if(of==stdout)
utils_trace("device %d %s %s\n", i, uid, nullConfig? "" : configStr);
else
fprintf(of, "device %d %s %s\n", i, uid, nullConfig? "" : configStr);
}
}
return 0;
}
void
_executer_conflict_path (const char *file, char **path)
{
char date_formatted[50];
const char time_format[] = "%Y_%m_%d_%H_%M_%s";
char *path2;
char *base;
time_t date;
struct tm *date_tm;
base = basename (file);
date = time (NULL);
date_tm = gmtime (&date);
strftime (date_formatted, 50, time_format, date_tm);
path2 =
malloc (strlen (config.conflicts) + strlen (base) +
strlen (date_formatted) + 3);
strcpy (path2, config.conflicts);
strcat (path2, "/");
strcat (path2, base);
strcat (path2, ".");
strcat (path2, date_formatted);
utils_trace ("file: '%s' conflict path: '%s'", file, path2);
*path = path2;
}
__bool switch_to_backup()
{
UTILS_TIME t1, t2;
__bool ret;
time_mark(&t1);
utils_trace(">> %s : switching to backup mode ....\n", _texttime().data());
ret = set_power_state(PWR_BACKUP);
time_mark(&t2);
utils_trace(
">> Mode switch %s , time elapsed is %.3f seconds.\n",
ret? "OK" : "FAILED.",
time_diff(&t2, &t1)
);
return ret;
}
void CRtkService::Stop()
{
if(m_bPending){
return;
}
m_bPending = __true;
utils_trace("PMC Runtime Kernel is shutting down....\n");
ReportStatus(SERVICE_STOP_PENDING, 11000);
m_dwStopReason = 0;
m_hStop.Fire();
}
/*
功能：读取配置文件[PMC]下的MaxChangeRate和TagLife
参数：无
返回：无
*/
static void _load_settings()
{
char buf[32];
*buf = 0;
GetPrivateProfileString(
"PMC",
"MaxChangeRate",
"0.01",
buf,
sizeof(buf),
get_config_file()
);
g_fltMaxChangeRate = (__r4)atof(buf);
if(g_fltMaxChangeRate < 0.0001 || g_fltMaxChangeRate > 5){
utils_error(
"MaxChangeRate=%.3f%% is not valid.\n",
g_fltMaxChangeRate
);
g_fltMaxChangeRate = (__r4)rtkm_default_change_rate;
}
utils_trace("MaxChangeRate is set to %.3f%% \n", g_fltMaxChangeRate);
*buf = 0;
GetPrivateProfileString(
"PMC",
"TagLife",
"60",
buf,
sizeof(buf),
get_config_file()
);
g_fltTagLife = (__r4)atof(buf);
if(g_fltTagLife < 5){
utils_error(
"TagLife=%.1fs is not valid, reset to 5s.\n",
g_fltTagLife
);
}
utils_trace("TagLife is set to %.1fs\n", g_fltTagLife);
}
bool bring_up_backups()
{
CBringupBackups * tr;
/*
mode probing must be done in backup mode
*/
assert(PWR_BACKUP == get_power_state());
utils_trace("Bringing up backup sites ...\n");
tr = new CBringupBackups(2000);
if(tr->m_bOk){
utils_trace("Backup site acknowledged, no off-line broadcast will be made.\n");
return true;
}else if(tr->m_bTimeout){
utils_trace("Backup site not found, continue unloading.\n");
}else{
utils_trace("Backup site mode-switch failed, continue unloading.\n");
}
return false;
}
void
_executer_real_path (const char *file, char **path)
{
char *path2;
path2 = malloc (strlen (config.path) + strlen (file) + 1);
strcpy (path2, config.path);
strcat (path2, file);
utils_trace ("file: '%s' real path: '%s'", file, path2);
*path = path2;
}
int on_help(char * v, void *k)
{
CArgsEx b;
int i;
int count;
count = sizeof(commands)/sizeof(commands[0]) - 1;
b.parse(v, FS);
if(b.argc == 1){
for(i=0; i<count; i++){
utils_trace(
"\t%10s : %s\n",
commands[i].name,
commands[i].brief_description
);
}
}else{
for(i=1; i<b.argc; i++){
int j;
for(j=0; j<count; j++){
if(strcmp(commands[j].name, b[i])){
continue;
}
utils_trace(
"\t%10s : %s\n",
commands[j].name,
commands[j].brief_description
);
break;
}
if(j >= count){
// not found
utils_error("%s : not found.\n", b[i]);
}
}
}
return F8_SUCCESS;
}
__bool CSerialPort::flush()
{
if(INVALID_HANDLE_VALUE != m_hFile){
PurgeComm(
m_hFile,
PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR
);
}
utils_trace("COM%d flushed.\n", m_iPortNo);
return __true;
}
static void dump_map(int idx)
{
mem_addr_t addr;
char path[F8_MAX_PATH];
int i;
if(!_is_valid_section(idx)){
return;
}
reg_map * rm = &g_regmap[idx];
reg_map_ent * e = rm->bitmap;
void * owner = 0;
const blk_var_t * var;
addr.section = idx;
for(i=0; i<rm->total_items; i++, e++){
if(!e->owner){
continue;
}
addr.addr = i;
if(e->owner != owner){
owner = e->owner;
utils_trace(
"%%%d%05d owned by ",
idx,
i
);
var = query_var_by_addr(&addr);
if(var){
IBlk_path_by_blk(var->blk, path, sizeof(path));
utils_trace("{%s}.%s", path, var->name);
}else{
IBlk_path_by_pin((struct blk_pin_t*)owner, path, sizeof(path));
utils_trace("%s", path);
}
utils_trace("\n");
}
}
}
bool CRtkService::_restart()
{
utils_trace("Restarting %s...\n", versionString.c_str());
if(!_uninit()){
return false;
}
if(!_init()){
return false;
}
restart_time(true);
return true;
}
static __bool defineVariable(struct blk_var_t * v, __uint context)
{
FILE * of = (FILE*)context;
char buf[1024];
char path[F8_MAX_PATH];
const char *tp = _type_name(v->type);
IBlk_path_by_blk(v->blk, path, sizeof(path));
sprintf(buf, "set type=%s name=\"%s\" comment=\"%s\" scope=\"%s\"", tp, v->name, v->comment, path);
if (of==stdout)
utils_trace("%s\n", buf);
else
fprintf(of, "%s\n", buf);
return __true;
}
rs_result
_executer_out_callback (rs_job_t * job, rs_buffers_t * buf, void *opaque)
{
executer_rs *executer = (executer_rs *) opaque;
if (buf->next_out == 0)
{
buf->next_out = executer->buf;
buf->avail_out = executer->size;
}
if (buf->avail_out < 20 || (buf->avail_in == 0 && buf->eof_in))
{
utils_trace ("Sending %i bytes from buffer ",
executer->size - buf->avail_out);
//Enviamos ya lo que hay
if (executer->type == _EXECUTER_FILE)
{
if (!_executer_send_buffer
(executer->sock, executer->buf,
executer->size - buf->avail_out))
{
utils_error ("Error writing %i bytes, cancelling job",
executer->size - buf->avail_out);
return RS_IO_ERROR;
}
}
else
{
if (!_executer_send_part
(executer->sock, executer->buf,
executer->size - buf->avail_out))
{
utils_error ("Error writing %i bytes, cancelling job",
executer->size - buf->avail_out);
return RS_IO_ERROR;
}
}
buf->avail_out = executer->size;
buf->next_out = executer->buf;
return RS_DONE;
}
else
{
//Todavia no enviamos
return RS_DONE;
}
}
/*
caller must have DB locked exclusively.
*/
IO_API __bool PMC_API io_stop_device(PDEVICE_INFO dev)
{
if( !(dev->flags & DF_Active) ){
return __true;
}
utils_trace("Stopping device %s\n", (char*)CDeviceName(dev->k));
// newly created devices might not be attached to driver yet
if(dev->d){
if(dev->d->stop_device){
if(!dev->d->stop_device(dev)){
dev->flags &= ~DF_Active;
utils_error(
"Device %s not responding to STOP command.\n",
(char*)CDeviceName(dev->k)
);
return __false;
}
}
}
dev->flags &= ~DF_Active;
utils_trace("Device %s stopped\n", (char*)CDeviceName(dev->k));
return __true;
}
int on_memusage(char *v, void *k)
{
int i;
reg_map * m;
for(i=0, m=g_regmap; i<KERN_NUM_SECTIONS; i++, m++){
utils_trace(
"section %d total=%d used=%d free=%d\n",
i,
m->total_items,
m->total_items-m->free_items,
m->free_items
);
}
return F8_SUCCESS;
}
static int init(void)
{
utils_trace(">> Starting scheduler...\n");
for(int i=0;i<rtkm_max_spac_ports;i++){
g_Brokers[i] = new CScheduler(i+1);
if(!g_Brokers[i]){
utils_error("Create thread %d failed.\n",i);
return 0;
}
g_Brokers[i]->start();
if(WAIT_OBJECT_0 != g_Brokers[i]->wait(CRtkThread::EVT_INIT_COMPLETE, 5000)){
utils_error("Scheduler thread %d init failed.\n",i);
return 0;
}
}
return 1;
}
int on_mmap(char *v, void *k)
{
CArgs args;
int i;
parse_arg_ex(v, &args, FS);
if(args.argc == 1){
for(i=0; i<KERN_NUM_SECTIONS; i++){
utils_trace("Dump of memory section %d\n", i);
dump_map(i);
}
}else{
for(i=1; i<args.argc; i++){
dump_map(atoi(args.argv[i]));
}
}
return F8_SUCCESS;
}
/*
caller must have DB locked exclusively
*/
IO_API __bool PMC_API io_start_device(PDEVICE_INFO dev)
{
__bool r;
// a fake driver is created even if the module cannot be loaded
assert(dev->d);
if(!(dev->d->flags & DRIVER_FLAG_LOADED)){
dev->error = IOSS_DRIVER_NOT_LOADED;
r = __false;
}else{
if(!dev->d->start_device){
r = __true;
}else{
r = dev->d->start_device(dev);
if(!r){
dev->error = IOSS_DEVICE_NOT_STARTED;
}
}
}
if(!r){
dev->flags &= ~DF_Active;
}else{
dev->flags |= DF_Active;
dev->error = 0;
}
if(r){
utils_trace(
"Device %s started.\n",
(char*)CDeviceName(dev->k)
);
}else{
utils_error(
"Cannot start device %s.\n",
(char*)CDeviceName(dev->k)
);
}
return r;
}
IO_API __bool PMC_API io_unload_driver(PDRIVER_INFO driver)
{
DRIVER_LIST::iterator it;
utils_trace("Unloading driver %s\n", driver->dllname);
for(it = g_Drivers.begin(); it != g_Drivers.end(); it++){
if(&(*it) == driver){
break;
}
}
if(it == g_Drivers.end()){
DEBUG_PRINTF((
"Warning : unload a non-existing driver : 0x%08x\n", driver
));
return __false;
}
if(driver->device_count){
utils_error(
"Driver %s cannot unload with %d devices active.\n",
driver->dllname,
driver->device_count
);
return __false;
}
if(driver->unload){
if(!driver->unload()){
DEBUG_PRINTF((
"Error : driver %s rejected unload request.\n",
driver->dllname
));
return __false;
}
}
if(driver->plugin_handle){
FreeLibrary((HINSTANCE)driver->plugin_handle);
}
g_Drivers.erase(it);
return __true;
}
int dump_memory(DWORD PID,PBYTE pbStartingAddress,DWORD iLength,char * szFile)
{
FILE * fp=fopen(szFile,"wb+");
void * pbMemory;
DWORD iRead;
HANDLE hProcess;
utils_debug("Dumping Process : %08x, from %08x, length %08x, to file %s.\n",PID,pbStartingAddress,iLength,szFile);
if(!fp){
utils_error("Open %s(read/write) failed.\n",fp);
return 0;
};
pbMemory=malloc(iLength);
if(!pbMemory){
utils_error("Memory allocation failed (%d bytes).\n",iLength);
fclose(fp);
return 0;
};
if( !(hProcess=OpenProcess(PROCESS_ALL_ACCESS,0,PID)) ){
wperror("OpenProcess failed:");
free(pbMemory);
fclose(fp);
return 0;
}
if( !ReadProcessMemory(hProcess,pbStartingAddress,pbMemory,iLength,&iRead)){
wperror("ReadProcessMemory failed:");
free(pbMemory);
fclose(fp);
return 0;
};
fwrite(pbMemory,1,iLength,fp);
utils_trace("Ok, %d bytes written.\n",iLength);
free(pbMemory);
fclose(fp);
return 1;
};
bool CRtkService::_uninit()
{
bool is_server;
is_server = get_power_state()==PWR_RUNNING? true : false;
utils_trace("Please stand-by ...\n");
switch_to_backup();
uninit_ioss();
utils_trace("IO subsystem stopped.\n");
destroy_rtdb();
utils_trace("Realtime Database Subsystem closed.\n");
#ifdef _WIN32
uninit_spac();
#endif
utils_trace("IO Subsystem closed.\n");
if(is_server){
if(!bring_up_backups()){
offline_broadcast();
}
}
unregister_power_callback(power_state_changed, 0);
uninit_network();
utils_trace("Networking subsystem closed.\n");
utils_trace("%s stopped.\n", versionString.c_str());
uninit_config();
uninit_server_shell();
return true;
}
/*
expand or shrink section memory size
usage
memsize [section_id] [size]
*/
int on_memsize(char *v, void *k)
{
int i;
CArgs a;
_shproc_prolog_();
parse_arg_exA(v, &a, FS);
if(a.argc == 1){
for(i=0; i<KERN_NUM_SECTIONS; i++){
utils_trace("memsize %d %d \n", i, g_regmap[i].total_items);
}
}else if(a.argc == 3){
int newSize;
i = atoi(a.argv[1]);
newSize = atoi(a.argv[2]);
if(newSize < g_regmap[i].total_items){
// memory shrinking is not implemented
utils_error("memory shrinking is dangerous.\n");
// return F8_UNIMPLEMENTED;
}
if(newSize > MAP_ENTRIES){
return F8_LOW_REGISTERS;
}
if(proxy_adapter->flags & ADAPTER_F_ONLINE){
return F8_INVALID_OPERATION;
}
/*
load memory configuration
*/
struct ctrller_config cfg;
cmd.cmd = F8_GET_SYS_CONFIG;
cmd.osize = sizeof(struct ctrller_config);
cmd.obuffer = (char *)&cfg;
__vcall__(
proxy_adapter,
exec,
(proxy_adapter, &cmd, 5000)
);
if(!successful){
return cmd.retcode;
}
cfg.x_mem_sizes[i]=newSize;
cmd.cmd=F8_SET_SYS_CONFIG;
cmd.isize=sizeof(cfg);
cmd.osize=0;
cmd.ibuffer=&cfg;
__vcall__(
proxy_adapter,
exec,
(proxy_adapter, &cmd, 5000)
);
if(!successful){
return cmd.retcode;
}
g_regmap[i].free_items += newSize - g_regmap[i].total_items;
g_regmap[i].total_items = newSize;
}
return F8_SUCCESS;
}
__bool CSerialPort::open()
{
char buf[64];
DCB dcb;
COMMTIMEOUTS tout;
if(INVALID_HANDLE_VALUE != m_hFile){
return __true;
}
sprintf(buf, "\\\\.\\COM%d", m_iPortNo);
m_hFile = CreateFile(
buf,
GENERIC_READ | GENERIC_WRITE,
0,
0,
OPEN_EXISTING,
FILE_FLAG_OVERLAPPED,
0
);
utils_trace(
"COM %d opened as 0x%08x\n",
m_iPortNo,
m_hFile
);
if(INVALID_HANDLE_VALUE==m_hFile){
return __false;
}
get_config_string();
if( !setup_dcb(m_Setting, &dcb) ){
close();
utils_trace(
"COM%d, error in setting string : %s, code %d\n",
m_iPortNo,
m_Setting,
GetLastError()
);
return __false;
}
if( !SetCommState(m_hFile, &dcb) ){
utils_error(
"COM%d, SetCommState failed with %d.\n",
m_iPortNo,
GetLastError()
);
close();
}
utils_trace(
"Ok, COM%d setting applied : '%s'\n",
m_iPortNo,
m_Setting
);
if( !GetCommTimeouts(m_hFile, &tout) ){
close();
utils_trace(
"COM%d, Error in GetCommTimeouts, Code %d.\n",
m_iPortNo,
GetLastError()
);
return __false;
}
tout.ReadIntervalTimeout = MAXDWORD;
tout.ReadTotalTimeoutMultiplier = 0;
tout.ReadTotalTimeoutConstant = 0;
tout.WriteTotalTimeoutMultiplier = 10;
tout.WriteTotalTimeoutConstant = 0;
if(!SetCommTimeouts(m_hFile, &tout)){
utils_trace(
"COM%d, Error in SetCommTimeouts, Code %d.\n",
m_iPortNo,
GetLastError()
);
close();
return __false;
}
m_OverlappedEvent = new CEvent(0, TRUE, FALSE);
if(!m_OverlappedEvent || !m_OverlappedEvent->Handle()){
utils_trace(
"COM%d, error %d creating overlapped event.\n",
m_iPortNo,
GetLastError()
);
close();
return __false;
}
if( !PurgeComm(
m_hFile,
PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR
)
){
utils_error(
"COM%d, Warning : PurgeComm failed with %d\n",
m_iPortNo,
GetLastError()
);
}
COMMCONFIG cfg;
DWORD size;
cfg.dwSize = size = sizeof(cfg);
if( !GetCommConfig(m_hFile, &cfg, &size) ){
utils_error(
"Warning : GetCommConfig failed with %d\n",
GetLastError()
);
}else{
utils_trace(
"COM%d setting is : '%d,%c,%d,%d(%08x)'\n",
m_iPortNo,
cfg.dcb.BaudRate,
Parity(&cfg.dcb),
cfg.dcb.ByteSize,
Stopbits(cfg.dcb.StopBits),
*((DWORD*)&cfg.dcb + 2)
);
}
return __true;
}
void _load_settings(__bool bSilent)
{
char buf[32];
if(!bSilent){
utils_trace("Loading proxy settings...\n");
}
g_NodeLife = GetPrivateProfileInt(
"PMC",
"NodeLife",
rtkm_default_node_life,
get_config_file()
);
if(g_NodeLife < 200 || g_NodeLife > 60000){
g_NodeLife = rtkm_default_node_life;
}
if(!bSilent){
utils_trace(
"Node will be kicked after idle for %d ms.\n",
g_NodeLife
);
}
*buf = 0;
GetPrivateProfileString(
"PMC",
"TagLife",
"120",
buf,
sizeof(buf),
get_config_file()
);
g_fltTagLife = (__r4)atof(buf);
if(g_fltTagLife < 5){
utils_error(
"TagLife=%.1fs is not valid, reset to %.1fs.\n",
g_fltTagLife,
rtkm_default_tag_life
);
g_fltTagLife = rtkm_default_tag_life;
}else{
if(!bSilent){
utils_trace("TagLife is set to %.1fs\n", g_fltTagLife);
}
}
CProxyWorker::m_MaxBgLoads = GetPrivateProfileInt(
"PMC",
"MaxBgLoad",
256,
get_config_file()
);
if(!bSilent){
utils_trace("BGLoader's queue length is %d entries.\n", CProxyWorker::m_MaxBgLoads);
}
g_QueryInterval = GetPrivateProfileInt(
"PMC",
"QueryInterval",
1000,
get_config_file()
);
if(g_QueryInterval < 1000 || g_QueryInterval > 30000){
if(!bSilent){
utils_error("QueryInterval=%d is invalid, setting to default.");
}
g_QueryInterval = 1000;
}
if(!bSilent){
utils_trace("Query interval set to %d.\n", g_QueryInterval);
}
}
void CSerialPort::check_error()
{
DWORD len;
COMSTAT stat;
char errStr[256];
if(INVALID_HANDLE_VALUE == m_hFile){
SetLastError(ERROR_INVALID_HANDLE);
return;
}
memset(&stat, 0, sizeof(stat));
if( !ClearCommError(m_hFile, (LPDWORD)&len, &stat) ){
utils_trace(
"Err in ClearCommError, code %d\n",
GetLastError()
);
return;
}
ClearCommBreak(m_hFile);
if(!len){
return;
}
errStr[0] = 0;
#define chk(e) \
do{if(len & e) {\
strcat(errStr, #e); \
strcat(errStr, " ");\
}}while(0)
chk(CE_BREAK);
chk(CE_DNS);
chk(CE_FRAME);
chk(CE_IOE);
chk(CE_MODE);
chk(CE_OOP);
chk(CE_OVERRUN);
chk(CE_PTO);
chk(CE_RXOVER);
chk(CE_RXPARITY);
chk(CE_TXFULL);
utils_trace(
"Err 0x%08x(%s) on COM%d, COMSTAT=(0x%08x, 0x%08x, 0x%08x)\n",
len,
errStr,
m_iPortNo,
*((DWORD*)&stat),
stat.cbInQue,
stat.cbOutQue
);
if(len & CE_RXOVER){
PurgeComm(m_hFile, PURGE_RXCLEAR | PURGE_RXABORT);
}
if(len & CE_TXFULL){
PurgeComm(m_hFile, PURGE_TXCLEAR | PURGE_TXABORT);
}
}
