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; }