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