void init_signals(void) { struct sigaction action; sigset_t blocked_sigset; if (!(handler_sighup = create_handler( sighup_callback ))) goto error; if (!(handler_sigterm = create_handler( sigterm_callback ))) goto error; if (!(handler_sigint = create_handler( sigint_callback ))) goto error; if (!(handler_sigchld = create_handler( sigchld_callback ))) goto error; if (!(handler_sigio = create_handler( sigio_callback ))) goto error; sigemptyset( &blocked_sigset ); sigaddset( &blocked_sigset, SIGCHLD ); sigaddset( &blocked_sigset, SIGHUP ); sigaddset( &blocked_sigset, SIGINT ); sigaddset( &blocked_sigset, SIGALRM ); sigaddset( &blocked_sigset, SIGIO ); sigaddset( &blocked_sigset, SIGQUIT ); sigaddset( &blocked_sigset, SIGTERM ); #ifdef SIG_PTHREAD_CANCEL sigaddset( &blocked_sigset, SIG_PTHREAD_CANCEL ); #endif action.sa_mask = blocked_sigset; action.sa_flags = 0; action.sa_handler = do_sigchld; sigaction( SIGCHLD, &action, NULL ); #ifdef SIG_PTHREAD_CANCEL sigaction( SIG_PTHREAD_CANCEL, &action, NULL ); #endif action.sa_handler = do_sighup; sigaction( SIGHUP, &action, NULL ); action.sa_handler = do_sigint; sigaction( SIGINT, &action, NULL ); action.sa_handler = do_sigalrm; sigaction( SIGALRM, &action, NULL ); action.sa_handler = do_sigterm; sigaction( SIGQUIT, &action, NULL ); sigaction( SIGTERM, &action, NULL ); if (core_dump_disabled()) { action.sa_handler = do_sigsegv; sigaction( SIGSEGV, &action, NULL ); } action.sa_handler = SIG_IGN; sigaction( SIGXFSZ, &action, NULL ); #ifdef HAVE_SIGINFO_T_SI_FD action.sa_sigaction = do_sigio; action.sa_flags = SA_SIGINFO; sigaction( SIGIO, &action, NULL ); #endif return; error: fprintf( stderr, "failed to initialize signal handlers\n" ); exit(1); }
////////////////////////////////////////////////////////////////////////// // KSGDevice int KSGDevice::ExecuteTask(DeviceNodeType* node,Task* task) { // 检查是否支持指令 DI * devintr = FindDevInterface(task->GetTaskCode()); if(!devintr) { throw TaskNotSupportedException(); } // int ret; ACE_HANDLE handler; // 先检查 handler 是否可用 if(node->GetState() == KSGDeviceNode::dsOffline) { ret = create_handler(node,&handler); } else if((ret = find_handler(node,&handler))) { // 尝试连接 ret = create_handler(node,&handler); if(ret) { // 连接失败 node->SetState(KSGDeviceNode::dsOffline); } } if(ret) { return TASK_ERR_CONNECT; } // 执行指令 ret = devintr->ExecuteTask(node,task); if(ret) { // 如果指令执行超时 if(ret == TASK_ERR_TIMEOUT) { // 尝试重新连接 if(create_handler(node,&handler)) { // 重连失败 node->SetState(KSGDeviceNode::dsError); } } } return ret; }
HandlerBase* HandlerBase::get(const string name) { static map<string, HandlerBase* > handlers; if (handlers.find(name) != handlers.end()) return handlers[name]; string filename = "./lib" + name + ".so"; void* h = dlopen(filename.c_str(), RTLD_LAZY); if (!h){ perror("dl open failed: "); exit(1); } string create_handler_s = "create_" + name; HandlerBase::create_handler_t create_handler = (HandlerBase::create_handler_t)dlsym(h, create_handler_s.c_str()); HandlerBase* hb; handlers[name] = hb = create_handler(); INIConfig& c = Singleton<INIConfig>::instance(); string next = c.get_value_s("[" + name + "]", "next"); if (next != ""){ HandlerBase* next_handler = HandlerBase::get(next); hb->next(next_handler); } return hb; }
/* void imeGetAvailableEngines (out AString enginesList); */ NS_IMETHODIMP nsNativeEvents::ImeGetAvailableEngines(nsIArray **enginesList) { NS_ENSURE_ARG_POINTER(enginesList); *enginesList = nsnull; LOG(DEBUG) << "getting available engines"; IMELIB_TYPE lib = tryToOpenImeLib(); if (lib) { create_h* create_handler = getCreateHandler(lib); ImeHandler* handler = create_handler(); std::vector<std::string> engines = handler->GetAvailableEngines(); LOG(DEBUG) << "Number of engines received: " << engines.size(); nsCOMPtr<nsIMutableArray> returnArray = do_CreateInstance(NS_ARRAY_CONTRACTID); NS_ENSURE_TRUE(returnArray, NS_ERROR_FAILURE); fillIMutableArrayFromVector(engines, returnArray); NS_ADDREF(*enginesList = returnArray); tryToCloseImeLib(handler, lib); LOG(DEBUG) << "Done getAvailableEngines."; return NS_OK; } return NS_ERROR_FAILURE; }
/* void imeDeactivate (); */ NS_IMETHODIMP nsNativeEvents::ImeDeactivate() { LOG(DEBUG) << "Deactivating IME"; IMELIB_TYPE lib = tryToOpenImeLib(); if (lib) { create_h* create_handler = getCreateHandler(lib); ImeHandler* handler = create_handler(); handler->Deactivate(); tryToCloseImeLib(handler, lib); return NS_OK; } return NS_ERROR_FAILURE; }
void xml_valuator_t::open_tag(const std::string& name) { if (name == "expressions") { os << "<" << name << ">" << std::endl; } if (!handler) { handler = create_handler(name); return; } if (handler) handler->open_tag(name); }
/* void imeIsActivated (out boolean isActive); */ NS_IMETHODIMP nsNativeEvents::ImeIsActivated(PRBool *isActive) { LOG(DEBUG) << "Getting if IME is active or not"; IMELIB_TYPE lib = tryToOpenImeLib(); if (lib) { create_h* create_handler = getCreateHandler(lib); ImeHandler* handler = create_handler(); *isActive = handler->IsActivated(); tryToCloseImeLib(handler, lib); LOG(DEBUG) << "All done. value: " << *isActive; return NS_OK; } return NS_ERROR_FAILURE; }
/* void imeGetActiveEngine (out string activeEngine); */ NS_IMETHODIMP nsNativeEvents::ImeGetActiveEngine(nsAString &activeEngine) { LOG(DEBUG) << "Getting active engine"; IMELIB_TYPE lib = tryToOpenImeLib(); if (lib) { create_h* create_handler = getCreateHandler(lib); ImeHandler* handler = create_handler(); std::string engine = handler->GetActiveEngine(); LOG(DEBUG) << "Active engine:" << engine; std::wstring wengine(engine.begin(), engine.end()); // We know that PRUnichar* is wchar_t*. see comment in sendKeys activeEngine.Assign((const PRUnichar*) wengine.c_str(), wengine.length()); tryToCloseImeLib(handler, lib); return NS_OK; } return NS_ERROR_FAILURE; }
/* create P2P discovery */ bcm_p2p_discovery_t *bcm_p2p_discovery_create( struct bcm_p2p_discovery_wl_drv_hdl *drv, uint16 listenChannel) { bcm_p2p_discovery_req_t req; create_rsp_t rsp; WL_TRACE(("bcm_p2p_discovery_create\n")); req.handler = create_handler; req.create.drv = drv; req.create.listenChannel = listenChannel; #ifdef BCM_P2P_DISCOVERY_NO_DISPATCHER create_handler(0, sizeof(req), &req, &rsp); #else if (!dspRequestSynch(dsp(), 0, sizeof(req), (uint8 *)&req, (uint8 *)&rsp)) { return 0; } #endif /* BCM_P2P_DISCOVERY_NO_DISPATCHER */ return rsp.disc; }
static void syscall_handler(struct intr_frame *f) { void *esp = f->esp; thread_current()->saved_esp = f->esp; // printf("$esp = %p\n",esp); byte_access_ok(esp,false); // hex_dump(esp, esp,16,true); // printf("\n"); int sys_call_num = *(int*) esp; esp += sizeof(int *); byte_access_ok(esp,false); // printf("$sys_call_num = %p\n",sys_call_num); char* argv[5]; switch (sys_call_num) { /* Projects 2 and later. */ //TODO: please retrieve parameters from the stack // and pass them to the handlers. case SYS_HALT: /* Halt the operating system. */ halt_handler(); break; case SYS_EXIT: /* Terminate this process. */ parse_arg(esp, 1, argv); exit_handler((int) argv[0]); break; case SYS_EXEC: /* Start another process. */ parse_arg(esp, 1, argv); f->eax=exec_handler((void*)argv[0]); break; case SYS_WAIT: /* Wait for a child process to die. */ parse_arg(esp, 1, argv); f->eax=wait_handler((int) argv[0]); break; case SYS_CREATE: /* Create a file. */ parse_arg(esp, 2, argv); f->eax=create_handler((void*)argv[0], (unsigned) argv[1]); break; case SYS_REMOVE: /* Delete a file. */ parse_arg(esp, 1, argv); f->eax=remove_handler((void*)argv[0]); break; case SYS_OPEN: /* Open a file. */ parse_arg(esp, 1, argv); f->eax=open_handler((void*)argv[0]); break; case SYS_FILESIZE: /* Obtain a file's size. */ parse_arg(esp, 1, argv); f->eax=filesize_handler((int) argv[0]); break; case SYS_READ: /* Read from a file. */ parse_arg(esp, 3, argv); f->eax=read_handler((int) argv[0], (void*) argv[1], (unsigned) argv[2]); break; case SYS_WRITE: /* Write to a file. */ parse_arg(esp, 3, argv); f->eax=write_handler((int) argv[0], (void*) argv[1], (unsigned) argv[2]); break; case SYS_SEEK: /* Change position in a file. */ parse_arg(esp, 2, argv); seek_handler((int) argv[0], (unsigned) argv[1]); break; case SYS_TELL: /* Report current position in a file. */ parse_arg(esp, 1, argv); f->eax=tell_handler((int) argv[0]); break; case SYS_CLOSE: /* Close a file. */ parse_arg(esp, 1, argv); close_handler((int) argv[0]); break; case SYS_MMAP: parse_arg(esp, 2, argv); f->eax=mmap_handler ((int) argv[0], (void*)argv[1]); break; case SYS_MUNMAP: parse_arg(esp, 1, argv); munmap_handler ((mapid_t) argv[0]); break; default: printf("system call %d not implemented!\n", sys_call_num); } //thread_exit(); }
int main(int argc, char* argv[]) { int pid; Msg myMsg; int sender_pid; initialize(); if (Register(FILE_SERVER)) { perror("Register server process error!"); } if (argc>1) { pid = Fork(); if (pid==0) { Exec(argv[1],argv+1); } } while (1) { if ((sender_pid=Receive(&myMsg))==ERROR) { // perror("error receiving message!"); continue; } switch (myMsg.type) { case OPEN: open_handler(&myMsg,sender_pid);break; /* case CLOSE: close_handler(&myMsg,sender_pid);break; */ case CREATE: create_handler(&myMsg,sender_pid);break; case READ: read_handler(&myMsg,sender_pid);break; case WRITE: write_handler(&myMsg,sender_pid);break; /* case SEEK: seek_handler(&myMsg,sender_pid);break; */ case LINK: link_handler(&myMsg,sender_pid);break; case UNLINK: unlink_handler(&myMsg,sender_pid);break; case SYMLINK: symlink_handler(&myMsg,sender_pid);break; case READLINK: readlink_handler(&myMsg,sender_pid);break; case MKDIR: mkdir_handler(&myMsg,sender_pid);break; case RMDIR: rmdir_handler(&myMsg,sender_pid);break; case CHDIR: chdir_handler(&myMsg,sender_pid);break; case STAT: stat_handler(&myMsg,sender_pid);break; case SYNC: sync_handler(&myMsg);break; case SHUTDOWN: shutdown_handler(&myMsg,sender_pid);break; default: perror("message type error!"); break; } if (Reply(&myMsg,sender_pid)==ERROR) fprintf(stderr, "Error replying to pid %d\n",sender_pid); } terminate(); return 0; }
/* void imeActivateEngine (in string engine, out boolean activationSucceeded); */ NS_IMETHODIMP nsNativeEvents::ImeActivateEngine(const char *engine, PRBool *activationSucceeded) { LOG(DEBUG) << "Activating IME engine " << engine; IMELIB_TYPE lib = tryToOpenImeLib(); if (lib == NULL) { return NS_ERROR_FAILURE; } create_h* create_handler = getCreateHandler(lib); ImeHandler* handler = create_handler(); // 1. Make sure the requested engine is in the list of installed engines. std::string engine_name(engine); std::vector<std::string> engines = handler->GetAvailableEngines(); if (std::find(engines.begin(), engines.end(), engine_name) == engines.end()) { // Not found LOG(DEBUG) << "Engine not installed."; *activationSucceeded = false; tryToCloseImeLib(handler, lib); return NS_OK; } // 2. If the engine is available but not loaded, load it. std::vector<std::string> loaded_engines = handler->GetInstalledEngines(); if (std::find(loaded_engines.begin(), loaded_engines.end(), engine_name) == loaded_engines.end()) { LOG(DEBUG) << "Engine not loaded, loading."; // Append the engine to the list of loaded engines - not to override // the engines already in use by the user. int currently_loaded = loaded_engines.size(); loaded_engines.push_back(engine_name); int newly_loaded = handler->LoadEngines(loaded_engines); LOG(DEBUG) << "Number of engines loaded:" << newly_loaded; // Make sure that the engine was loaded by comparing the number of engines // now loaded to the number of engines loaded before the LoadEngine call. if (currently_loaded + 1 != newly_loaded) { LOG(DEBUG) << "Engine is installed but could not be loaded."; *activationSucceeded = false; tryToCloseImeLib(handler, lib); return NS_OK; } // Wait for ibus to register the engine. Without the sleep statement here, // the call to ActivateEngine will fail. This is only needed on Linux. #ifdef BUILD_ON_UNIX sleep(1); #endif } else { LOG(DEBUG) << "Engine already loaded, not calling LoadEngines again."; } // 3. Finally, call ActivateEngine to immediately make this engine active. *activationSucceeded = handler->ActivateEngine(engine); LOG(DEBUG) << "Activation result: " << *activationSucceeded << " isActive: " << handler->IsActivated(); tryToCloseImeLib(handler, lib); return NS_OK; }
StateResult handle_accept(void* arg) { int connfd; sai_t client_addr; socklen_t caddr_sz = sizeof(client_addr); char ipaddr[INET_ADDRSTRLEN]; Handler *h, *new_h; ClientHandler *new_ch; int incoming=0,i=1; h = (Handler*) arg; incoming = kresult->data; while (incoming) { dout(2, "[%d]: %s processing event %d of %d\n", mypid, __FUNCTION__, i, incoming); if (is_nolisten) { dout(2, "[%d]: **** !!! I'm in NO Listen, but got request! ****\n", mypid); } memset(&client_addr, 0, sizeof(client_addr)); if ((connfd = accept(listenfd, (sa_t*) &client_addr, &caddr_sz)) < 0) { if (errno == EINTR || errno == EAGAIN) { dout(2, "[%d]: accept got '%s'; spin again.\n", mypid, strerror(errno)); return STATE_OKAY; } eout("[%d]: accept failed - [%d] %s\n", errno, strerror(errno)); } if (inet_ntop(AF_INET, &client_addr.sin_addr.s_addr, ipaddr, INET_ADDRSTRLEN) < 0) { eout("[%d]: can't decode client ip addr.\n"); close(connfd); return STATE_OKAY; } dout(2, "[%d]: got connfd %d { %s, %d }; " "spin up handler...\n", mypid, connfd, ipaddr, ntohs(client_addr.sin_port)); set_fd_nonblock(connfd); new_ch = create_clienthandler(BUF_SZ, BUF_SZ); new_h = create_handler(connfd, handle_client_intro, new_ch); // We first write an intro to the client and then enqueue on read. if (kmgr->enqueue_kevent(connfd, EVFILT_WRITE, EV_ADD|EV_ENABLE|EV_ONESHOT, new_h) < 0) { eout("[%d]: %s failed to enqueue kevent.\n", mypid, handle_accept); return STATE_ERROR; } incoming--; i++; } return STATE_OKAY; }
int main(int argc, char** argv) { int reqd = 0; int min_reqd = 2; int arg; opterr=0; int result; sai_t addr; char server[1024]; char port[32]; char prog[1024]; char debugconf[1024]; Handler *new_h; AcceptHandler *new_ah; init_output_api(); snprintf(prog,1024, "%s", argv[0]); dout(2, "kqueuer is running...\n"); memset(server,0,1024); memset(port,0,32); memset(prog,0,1024); memset(debugconf,0,1024); while ((arg = getopt(argc, argv, "d:s:p:")) != -1) { switch (arg) { case 's': if (optarg[0] == '-') { fprintf(stderr, "option -s has bad arg (leading '-')\n"); usage(prog); } snprintf(server,1024,"%s",optarg); reqd++; break; case 'p': if (optarg[0] == '-') { fprintf(stderr, "option -p has bad arg (leading '-')\n"); usage(prog); } snprintf(port,32,"%s",optarg); reqd++; break; case 'd': if (optarg[0] == '-') { fprintf(stderr, "option -d has bad arg (leading '-')\n"); usage(prog); } snprintf(debugconf, 1024, "%s", optarg); break; case 'v': version(prog); break; case 'a': about(prog); break; case 'h': default: usage(prog); }; }; argc -= optind; argv += optind; if (min_reqd > reqd) { fprintf(stderr, "Missing arguments. Try -h for more info.\n"); exit(1); } if (debugconf[0] != '\0' && atoi(debugconf) != 0) { set_debug_level(atoi(debugconf)); } else { set_debug_level(2); // default } memset(&addr, 0, sizeof(addr)); if (inet_pton(AF_INET, server, &addr.sin_addr.s_addr) < 0) { eout("kqueuer: failed to get network addr for 192.168.0.71.\n"); return NULL; } addr.sin_family = AF_INET; addr.sin_port = htons(atoi(port)); if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) { eout("kqueuer: failed to get socket - [%d] %s\n", errno, strerror(errno)); return NULL; } dout(2, "binding...\n"); if (bind(listenfd, (sa_t*) &addr, sizeof(addr)) < 0) { eout("kqueuer: failed to bind - [%d] %s\n", errno, strerror(errno)); return NULL; } dout(2, "listening...\n"); if (listen(listenfd, 16) < 0) { eout("kqueuer: failed to listen - [%d] %s\n", errno, strerror(errno)); return NULL; } int on=1; socklen_t onsz = sizeof(on); if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, onsz)<0) { eout("kqueuer: setsockopt failed - [%d] %s\n", errno, strerror(errno)); return NULL; } set_fd_nonblock(listenfd); ppid = getpid(); // fork result = rfork(RFPROC|RFNOWAIT|RFFDG); if (result == 0) { mypid = getpid(); dout(2, "I'm the child [PID: %d] (parent: %d)\n", mypid, ppid); } else { mypid = getpid(); dout(2, "I'm the parent [PID: %d]\n", mypid); } // // Both parent and child do the same thing... // is_nolisten = 0; kmgr = new KQueueManager(); // Add the listenfd to the kmgr dout(2, "[%d]: enqueue listenfd %d\n", mypid, listenfd); new_ah = create_accepthandler(); new_h = create_handler(listenfd, handle_accept, new_ah); if (kmgr->enqueue_kevent(listenfd, EVFILT_READ, EV_ADD | EV_ENABLE, new_h) < 0) { eout("[%d]: failed to enqueue kevent.\n", mypid); return NULL; } // Update the kqueue if (kmgr->update_kqueue() < 0) { eout("[%d]: failed to update kqueue.\n", mypid); return NULL; } dout(2, "[%d]: entering main processing loop...\n", mypid); // Enter main processing loop int nevents; kevent_t *cur_kevent; Handler *cur_h; StateResult sr; while (1) { dout(2, "[%d]: waiting (blocked) on kqueue for events...\n", mypid); if ((nevents = kmgr->get_kevents(KQueueManager::KQUEUE_BLOCK)) < 0) { eout("[%d]: get_kevents failed.\n", mypid); return NULL; } dout(2, "[%d]: got %d kevents (is_nolisten: %d).\n", mypid, nevents, is_nolisten); // All events in this kqueue are accept events, so we can handle // each one in the exact same way. while ((cur_kevent = kmgr->get_next_kevent()) != NULL) { dout(2, "[%d]: process event for ident %d\n", mypid, cur_kevent->ident); kresult = cur_kevent; cur_h = (Handler*) cur_kevent->udata; sr = (cur_h->handler)(cur_h); } dout(2, "[%d]: done processing kevents. process pevents...\n", mypid); while ((cur_h = (Handler*) kmgr->get_next_pevent()) != NULL) { dout(2, "[%d]: process pevent for h%d\n", mypid, cur_h->id); sr = (cur_h->handler)(cur_h); } dout(2, "[%d]: done processing pevents. wait for more...\n", mypid); // Update the kqueue if (kmgr->update_kqueue() < 0) { eout("[%d]: failed to update kqueue.\n", mypid); return NULL; } // Update the pending queue if (kmgr->update_pevents() < 0) { eout("[%d]: failed to update pending queue.\n", mypid); return NULL; } } dout(2, "[%d]: all done. goodbye.\n", mypid); return NULL; }