void CErrorDetector::show()
{
CInvalidList::iterator i1;
CConflictList::iterator i2;
char path[F8_MAX_PATH];
struct blk_pin_t * p;
struct blk_var_t * v;
for(i1 = m_invalidAddress.begin(); i1 != m_invalidAddress.end(); i1++){
if(i1->magic == PIN_MAGIC){
p = (struct blk_pin_t*)i1->o;
IBlk_path_by_pin(p, path, sizeof(path));
utils_error(
"pin %s, %%%d%05d invalid, type %d\n",
path, p->u2.mem_addr.section, p->u2.mem_addr.addr, i1->a
);
}else{
v = (struct blk_var_t*)i1->o;
IBlk_path_by_blk(v->blk, path, sizeof(path));
strncat(path, ".", sizeof(path));
strncat(path, v->name, sizeof(path));
utils_error(
"var %s, %%%d%05d invalid\n",
path, v->addr.section, v->addr.addr
);
}
}
}
executer_result
_executer_wait_modify (executer_job_t * job)
{
//Wait for read operation from the peer
int operation;
utils_debug ("Waiting for modify mode");
size_t leido =
_executer_read_buffer (job->peer_sock, &operation, sizeof (operation));
if (leido != sizeof (operation))
{
utils_error ("Error reading operation, cancelling job");
return EXECUTER_ERROR;
}
switch (operation)
{
case _EXECUTER_OK_EXISTS:
//In the other peer exists, send with librsync, next_operation is receive signature
job->next_operation = _executer_recive_signature;
return EXECUTER_RUNNING;
break;
case _EXECUTER_OK_NOT_EXISTS:
job->next_operation = _executer_send_file;
return EXECUTER_RUNNING;
break;
case _EXECUTER_REVERT:
return EXECUTER_END;
break;
}
utils_error ("Operation not permited: %i", operation);
return EXECUTER_ERROR;
}
executer_result
_executer_move_temp (executer_job_t * job)
{
utils_debug ("Moving temporay file '%s' to '%s'", job->tempfile,
job->realpath);
if (job->exists_real)
{
int ret = unlink (job->realpath);
if (ret != 0)
{
utils_error ("Error unlinking file '%s': %s", job->realpath,
strerror (errno));
return EXECUTER_ERROR;
}
}
int ret = rename (job->tempfile, job->realpath);
if (ret != 0)
{
utils_error ("Error renaming temporal file '%s' to '%s': %s",
job->tempfile, job->realpath, strerror (errno));
return EXECUTER_ERROR;
}
return EXECUTER_END;
}
CScheduler::CScheduler(int pno)
: CSerialPort(pno)
{
char name[32];
spac_shm * shm = (spac_shm *)&ports[m_iPortNo-1];
SECURITY_DESCRIPTOR sd, *pSD;
SECURITY_ATTRIBUTES sa,*_sa;
this->m_iPortNo = m_iPortNo;
pSD = &sd;
if (pSD == NULL){
utils_error("Error creating security descriptor.\n");
return;
}
if (!InitializeSecurityDescriptor(pSD, SECURITY_DESCRIPTOR_REVISION)){
utils_error("Error initializing security descriptor.\n");
return;
}
// Add a NULL DACL to the security descriptor..
// see MSDN Knowledge base Q106387 for detail
if (!SetSecurityDescriptorDacl(pSD, TRUE, (PACL) NULL, FALSE)){
utils_error("Error setting security descriptor.\n");
return;
}
sa.nLength = sizeof(sa);
sa.lpSecurityDescriptor = pSD;
sa.bInheritHandle = TRUE;
_sa=&sa;
sprintf(name,"rtkm_spac_event_0_%d",m_iPortNo);
m_hEvents[0]=CreateEvent(_sa, 0, 0, name);
if(!m_hEvents[0]){
m_hEvents[0]=OpenEvent(EVENT_ALL_ACCESS,0,name);
}
sprintf(name,"rtkm_spac_event_1_%d",m_iPortNo);
m_hEvents[1]=CreateEvent(_sa, 0, 0, name);
if(!m_hEvents[1]){
m_hEvents[1]=OpenEvent(EVENT_ALL_ACCESS,0,name);
}
shm->is_open=false;
if(!m_hEvents[0] || !m_hEvents[1]){
utils_error(
">> COM%d, Error creating event, code %d.\n",
m_iPortNo,
GetLastError()
);
m_hEvents[0]? CloseHandle(m_hEvents[0]) : 0;
m_hEvents[1]? CloseHandle(m_hEvents[1]) : 0;
return;
}
ports[m_iPortNo-1].port_no=m_iPortNo;
}
/*
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;
}
void CPacketMan::dbg_dump()
{
RECEIVE_ITEM *h;
RITEM_LIST::iterator p;
RTK_TIME now;
int i=0;
SITEM_LIST::iterator sit;
SEND_ITEM *si;
PRTK_LIST_ENTRY entry, headEntry;
rtk_time_mark(&now);
if(r_lst.size()){
utils_error("%d packets under construction:-->\n", r_lst.size());
p = r_lst.begin();
while(p != r_lst.end()){
headEntry = &(p->second);
entry = headEntry->Flink;
while(entry != headEntry){
h = RTK_CONTAINING_RECORD(entry, RECEIVE_ITEM, li);
utils_error("NO.%d, Age=%.3f, life=%.3f, ",
i,
rtk_time_diff(&now, &h->birthday),
h->life
);
utils_error("Got %d of Total %d fragments, size %d bytes\n",
h->header->total_frag - h->unreceived_fragments,
h->header->total_frag,
h->header->data_size
);
entry = entry->Flink;
}
p++;
i++;
}
}
if(s_lst.size()){
utils_error("%d packets in send queue:------>\n", s_lst.size());
sit = s_lst.begin();
i = 0;
while(sit != s_lst.end()){
headEntry = &sit->second;
entry = headEntry->Flink;
while(entry != headEntry){
si = RTK_CONTAINING_RECORD(entry, SEND_ITEM, li);
entry = entry->Flink;
utils_error("No.%d, %d fragments, age=%.3f, life=%.3f\n",
i, si->header->total_frag, rtk_time_diff(&now, &si->birthday),
si->life
);
i++;
}
sit++;
}
}
}
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;
}
}
executer_result
_executer_send_file (executer_job_t * job)
{
size_t leido;
FILE *file;
char buf[_EXECUTER_DEFAULT_OUT];
utils_debug ("Sending file data");
file = fopen (job->realpath, "r");
if (file == 0)
{
utils_error ("Error opening file '%s' for read: %s", job->realpath,
strerror (errno));
return EXECUTER_ERROR;
}
do
{
leido = fread (&buf, 1, _EXECUTER_DEFAULT_OUT, file);
if (leido == 0)
{
if (ferror (file))
{
utils_error ("Error reading file '%s': %s", job->realpath,
strerror (errno));
fclose (file);
return EXECUTER_ERROR;
}
}
if (!_executer_send_part (job->peer_sock, &buf, leido))
{
utils_error ("Error sending file data to peer: %s",
strerror (errno));
fclose (file);
return EXECUTER_ERROR;
}
}
while (!feof (file));
fclose (file);
_executer_send_finish (job->peer_sock);
job->next_operation = _executer_send_stat;
return EXECUTER_RUNNING;
}
CMutexLock::CMutexLock(const char * name)
{
#ifdef _WIN32
#ifndef UNDER_CE
SECURITY_ATTRIBUTES sa;
SECURITY_DESCRIPTOR sd;
InitializeSecurityDescriptor(&sd,SECURITY_DESCRIPTOR_REVISION);
SetSecurityDescriptorDacl(&sd,TRUE,NULL,FALSE);
sa.nLength = sizeof(SECURITY_ATTRIBUTES);
sa.bInheritHandle = FALSE;
sa.lpSecurityDescriptor = &sd;
LockData = CreateMutex(&sa, FALSE, name);
#else
LockData = CreateMutex(NULL, FALSE, name);
#endif
#elif defined(__LINUX__)
pthread_mutex_t * m = new pthread_mutex_t;
LockData = (void*)m;
if( LockData ){
pthread_mutex_init(m, NULL);
}
#endif
if(!LockData){
utils_error("Creating mutex lock %s failed.\n", name);
}
}
/*
功能：改变所有设备的power state
参数：
newState 设备将要达到的power state
context 函数体中木有用到。。。。。？？？？？
返回：0 __flase 失败
1 __true 成功
*/
static __bool PMC_API _power_callback(int newState, int context)
{
PDEVICE_INFO dev;
DEVICE_LIST::iterator it;
PDRIVER_INFO drv;
IOSS_STATUS code;
//遍历设备列表中的所有设备
for(it = g_Devices.begin(); it != g_Devices.end(); it++){
dev = it->second;//设备信息
drv = dev->d;//驱动信息
//调用驱动dll导出函数改变power state
if( (dev->flags & DF_Active) && (drv->dispatch)){
code = drv->dispatch(dev, DISP_POWER_STATE_CHANGED, newState);
if(code){
utils_error(
"Error : device %s vetoed `power-state-changed' command,"
"error code 0x%08x.\n"
"This may cause unpredictable result.\n",
(char*)CDeviceName(dev->k),
code
);
return __false;
}
}
}
return __true;
}
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;
}
executer_result
_executer_delete_dir (executer_job_t * job)
{
int ret;
struct stat buf;
char *path;
int return_value = EXECUTER_END;
_executer_real_path (job->file, &path);
utils_debug ("Deleting directory: '%s' whith real path '%s'", job->file,
path);
ret = lstat (path, &buf);
if (ret != 0)
{
utils_warn ("Error making lstat in file '%s': %s", path,
strerror (errno));
return_value = EXECUTER_ERROR;
}
if (rmdir (path) != 0)
{
utils_error ("Error deleting directory '%s': %s", path,
strerror (errno));
return_value = EXECUTER_ERROR;
}
free (path);
return return_value;
}
int main(int c, char **v)
{
char buf[1024];
CArgs args;
char *dirName = ".";
char *catagory=0;
char path[F8_MAX_PATH];
BEGIN_ARGS
ARG("-d:", dirName, "char *", "specify operation directory.")
ARG("-c:", catagory, "char *", "specify library catagory[dir name]")
END_ARGS
if(process_args_1(c, v)){
print_usage_1();
return -1;
}
if(!SetCurrentDirectory(dirName)){
utils_error("Cannot change directory to ``%s''.\n", dirName);
return -1;
}
GetCurrentDirectory(sizeof(buf), buf);
parse_arg_ex(buf, &args, ":/\\");
if(!catagory){
catagory = args.argv[args.argc-1];
}
GetCurrentDirectory(sizeof(path), path);
printf(
"Making library database in ``%s'', catagory ``%s''\n",
path,
catagory
);
fdb = fopen("f8.dir", "w");
if(!fdb){
return -1;
}
fprintf(fdb, "[library]\n");
fprintf(fdb, "catagory=%s\n", catagory);
enumerate_files(
".",
"*.blk",
_e_file,
0,
0);
fprintf(fdb, "count=%d\n", count);
fclose(fdb);
printf("%d entries added.\n", count);
return 0;
}
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;
}
/*
play commands contained in a script file
*/
int on_play(char *v, void *k)
{
CArgsExA a;
__bool silent;
a.parse(v, FS);
if(a.argc < 2){
utils_error("Usage : play <script file>\n");
return F8_SYNTAX;
}
FILE * fp;
fp = fopen(a.argv[1], "rt");
if(!fp){
utils_error("%s - cannot open.\n", a.argv[1]);
return F8_FILE_NOT_FOUND;
}
char buf[2048];
silent = proxy_silent;
proxy_silent = __true;
while(fgets(buf, sizeof(buf), fp), !feof(fp)){
// buf trimming
if(*buf == 0){
continue;
}
if(*buf == '\r' || *buf=='\n' || *buf=='#'){
continue;
}
char *p = buf + strlen(buf) - 1;
if(*p == '\r' || *p == '\n'){
*p = 0;
}
kproxy_shell(buf);
}
fclose(fp);
proxy_silent = silent;
return F8_SUCCESS;
}
/*
功能：读取配置文件[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 _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;
}
executer_result
_executer_check_exists (executer_job_t * job)
{
bool exists = false;
bool *conflict;
struct stat bufstat;
utils_debug ("Checking if file '%s' exists", job->realpath);
exists = !lstat (job->realpath, &bufstat);
if (exists)
{
job->exists_real = true;
// Send ok, the next steps are copy confict, send signature
int operacion = _EXECUTER_OK_EXISTS;
if (!_executer_send_buffer (job->peer_sock, &operacion, sizeof (int)))
{
utils_error ("Error sending data to peer.");
return EXECUTER_ERROR;
}
job->next_operation = _executer_copy_conflict;
return EXECUTER_RUNNING;
}
else
{
job->exists_real = false;
//Not exists, need all file
int operacion = _EXECUTER_OK_NOT_EXISTS;
if (!_executer_send_buffer (job->peer_sock, &operacion, sizeof (int)))
{
utils_error ("Error sending data to peer.");
return EXECUTER_ERROR;
}
job->next_operation = _executer_receive_file;
return EXECUTER_RUNNING;
}
}
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;
};
executer_result
_executer_mkdir (executer_job_t * job)
{
utils_debug ("Making directory '%s'", job->realpath);
if (mkdir (job->realpath, job->mode) != 0)
{
utils_error ("Error creating directory '%s': %s", job->realpath,
strerror (errno));
return EXECUTER_ERROR;
}
return EXECUTER_END;
}
/*
reconstruct register usage map.
called upon opening project and uploading project
*/
__bool build_reg_map()
{
CRegRequirementList req;
req.m_bGatherForDelete = false;
_traverse(sections, _gather_reg_usage, (__uint)&req);
if(F8_FAILED(req.m_errcode)){
utils_error("Warning : _gather_reg_usage failed %d(%s).\n", req.m_errcode, _errmsg(req.m_errcode));
}
req.Commit(__true);
return __true;
}
int
_executer_send_revert (executer_job_t * job)
{
utils_debug ("The file %s has operations after, send nothing operation.",
job->realpath);
int operacion = _EXECUTER_REVERT;
if (!_executer_send_buffer (job->peer_sock, &operacion, sizeof (int)))
{
utils_error ("Error sending data to peer.");
return EXECUTER_ERROR;
}
return EXECUTER_END;
}
void CErrorDetector::fix()
{
CInvalidList::iterator i1;
CConflictList::iterator i2;
char path[F8_MAX_PATH];
struct blk_pin_t * p;
struct blk_var_t * v;
for(i1 = m_invalidAddress.begin(); i1 != m_invalidAddress.end(); i1++){
if(i1->magic == PIN_MAGIC){
p = (struct blk_pin_t*)i1->o;
IBlk_path_by_pin(p, path, sizeof(path));
utils_error(
"pin %s, %%%d%05d invalid, type %d\n",
path, p->u2.mem_addr.section, p->u2.mem_addr.addr, i1->a
);
switch(i1->a){
case 0:
/* allocate a register for this PIN */
break;
case 1:
p->binding = PIN_B_CONST;
break;
case 2:
break;
}
}else{
v = (struct blk_var_t*)i1->o;
IBlk_path_by_blk(v->blk, path, sizeof(path));
strncat(path, ".", sizeof(path));
strncat(path, v->name, sizeof(path));
utils_error(
"var %s, %%%d%05d invalid\n",
path, v->addr.section, v->addr.addr
);
}
}
}
int
main (int argc, char **argv)
{
struct fuse_args args = FUSE_ARGS_INIT (argc, argv);
memset (&config, 0, sizeof (config));
if (fuse_opt_parse (&args, &config, myfs_opts, myfs_opt_proc))
{
utils_error ("Command line arguments error");
exit (EXIT_FAILURE);
}
if (config.path == NULL)
{
utils_error ("No path specified");
exit (EXIT_FAILURE);
}
FILE *log_stream = NULL;
if (config.log_file != NULL) {
log_stream = fopen(config.log_file, "a");
if(log_stream == NULL) {
utils_error ("The log file '%s' cannot be opened: %s", config.log_file, strerror(errno) );
exit (EXIT_FAILURE);
}
utils_set_log_stream(log_stream);
}
utils_set_log_debug_level(config.debug_level);
int ret = fuse_main (args.argc, args.argv, &xmp_oper, NULL);
if (log_stream != NULL) {
fclose(log_stream);
}
return ret;
}
static int uninit(void)
{
for(int i=0;i<rtkm_max_spac_ports;i++){
if(!g_Brokers[i]->stop(1000)){
utils_error(
"Warning:thread %d didn't exit in given time, force exit\n",
i
);
}
delete g_Brokers[i];
g_Brokers[i] = 0;
}
return 1;
}
executer_result
_executer_send_permission (executer_job_t * job)
{
mode_t mode;
struct stat stat2;
utils_debug ("Sending file permissions");
if (lstat (job->realpath, &stat2) != 0)
{
utils_error ("Error reading stat from file '%s': %s", job->realpath,
strerror (errno));
return EXECUTER_ERROR;
}
if (!_executer_send_buffer
(job->peer_sock, &(stat2.st_mode), sizeof (stat2.st_mode)))
{
utils_error ("Error sendig stat information, cancelling job");
return EXECUTER_ERROR;
}
return EXECUTER_END;
}
// 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);
}
int main( int argc, char *argv[] ) {
char *filename = NULL;
char *msg = NULL;
if ( argc == 2 ) {
filename = argv[ 1 ];
switch ( utils_validate_filename( filename ) ) {
case FILE_OK:
printf( "Input File: %s\n", filename );
parse_init( filename );
parse_assignment();
fclose( g_fptr );
break;
case BAD_EXTENSION:
msg = "Expected a file in the format of '< filename >.xwell'";
utils_error( msg, strlen( msg ) );
break;
default:
msg = "Unknown FILECHECK_t Error";
utils_error( msg, strlen( msg ) );
}
} else {
char msgbf[ 100 ] = "\0";
size_t n = sprintf( msgbf, "Usage - %s %s", argv[ 0 ], "< filename >.xwell" );
utils_error( msgbf, n );
}
msg = NULL;
filename = NULL;
exit( EXIT_SUCCESS );
}
/*
功能：初始化IOSS模块
参数：无
*/
IO_API __bool PMC_API init_ioss()
{
_load_settings();//通过pmc.in或程序默认，给几个相关变量赋初值g_fltMaxChangeRate、g_fltTagLife
register_power_callback(_power_callback, 0);//用形参对CALLBACK_ITEM的成员赋值，并链接到RTK_LIST_ENTRY
pnp_probe_devices();//加载设备驱动DLL，并得到其导出函数的指针
if(!CDBRefresher::init()){//add本地节点、组和标签；对g_Handlers[]中的函数指针赋值；开启一个线程
utils_error("Global initialization of CRefresher failed.\n");
return __false;
}
return __true;
}
executer_result
_executer_send_stat (executer_job_t * job)
{
struct stat stat2;
int ret;
utils_debug ("Sending stat data");
ret = lstat (job->realpath, &stat2);
if (ret != 0)
{
utils_error ("Error stat file '%s': %s", job->realpath,
strerror (errno));
return EXECUTER_ERROR;
}
if (!_executer_send_buffer (job->peer_sock, &stat2, sizeof (stat2)))
{
utils_error ("Error sending stat data to peer: %s", strerror (errno));
return EXECUTER_ERROR;
}
return EXECUTER_END;
}
