virtual void get_rate_limit(xmlrpc_c::paramList const& paramList, xmlrpc_c::value* retvalP) {
ACE_TRACE("modEmulateRate_Interface::get_rate");
int rate = 0;
if (paramList.size() > 2 ) {
rate = find_handler(paramList)->getRateLimitAtTime(paramList.getDouble(2));
}
else {
rate = find_handler(paramList)->getRateLimit();
}
*retvalP = xmlrpc_c::value_double(rate);
}
GList *
gnc_find_gui_components (const char *component_class,
GNCComponentFindHandler find_handler,
gpointer find_data)
{
GList *list = NULL;
GList *node;
if (!component_class)
return NULL;
for (node = components; node; node = node->next)
{
ComponentInfo *ci = node->data;
if (g_strcmp0 (component_class, ci->component_class) != 0)
continue;
if (find_handler && !find_handler (find_data, ci->user_data))
continue;
list = g_list_prepend (list, ci->user_data);
}
return list;
}
int KSGDevice::create_handler(KSGDeviceNode*node,ACE_HANDLE* handler)
{
ACE_HANDLE oldhandler;
int ret;
ret = make_handler(node,handler);
if(ret == 0)
{
ret = find_handler(node,&oldhandler);
if(ret == 0)
{
close_handler(node,oldhandler);
}
save_handler(node,*handler);
return 0;
}
else if(ret > 0)
{
if(node->GetParent() && node->GetParent()->GetDevice())
ret = node->GetParent()->GetDevice()->create_handler(node->GetParent(),handler);
return ret;
}
else
{
return -1;
}
}
// Handle a uri command
static bool uri_command(ast_t* ast, ast_t* uri, ast_t* alias, ast_t* guard,
pass_opt_t* options)
{
assert(uri != NULL);
assert(alias != NULL);
assert(guard != NULL);
const char* locator;
int index = find_handler(uri, &locator);
if(index < 0) // Scheme not found
return false;
if(ast_id(alias) != TK_NONE && !handlers[index].allow_name)
{
ast_error(alias, "Use scheme %s may not have an alias",
handlers[index].scheme);
return false;
}
if(ast_id(guard) != TK_NONE && !handlers[index].allow_guard)
{
ast_error(alias, "Use scheme %s may not have a guard",
handlers[index].scheme);
return false;
}
if(!ifdef_cond_eval(guard, options))
return true;
assert(handlers[index].handler != NULL);
return handlers[index].handler(ast, locator, alias, options);
}
virtual void clear_timeline(xmlrpc_c::paramList const& paramList, xmlrpc_c::value* retvalP) {
ACE_TRACE("modEmulateRate_Interface::clear_timeline");
find_handler(paramList)->clearTimeLine();
*retvalP = xmlrpc_c::value_nil();
}
unsigned int avctp_register_pdu_handler(struct avctp *session, uint8_t opcode,
avctp_control_pdu_cb cb,
void *user_data)
{
struct avctp_channel *control = session->control;
struct avctp_pdu_handler *handler;
static unsigned int id = 0;
if (control == NULL)
return 0;
handler = find_handler(control->handlers, opcode);
if (handler)
return 0;
handler = g_new(struct avctp_pdu_handler, 1);
handler->opcode = opcode;
handler->cb = cb;
handler->user_data = user_data;
handler->id = ++id;
control->handlers = g_slist_append(control->handlers, handler);
return handler->id;
}
/* Function: al_open_video
*/
ALLEGRO_VIDEO *al_open_video(char const *filename)
{
ALLEGRO_VIDEO *video;
const char *extension = filename + strlen(filename) - 1;
while ((extension >= filename) && (*extension != '.'))
extension--;
video = al_calloc(1, sizeof *video);
video->vtable = find_handler(extension);
if (video->vtable == NULL) {
ALLEGRO_ERROR("No handler for video extension %s - "
"therefore not trying to load %s.\n", extension, filename);
al_free(video);
return NULL;
}
video->filename = al_create_path(filename);
video->playing = true;
if (!video->vtable->open_video(video)) {
ALLEGRO_ERROR("Could not open %s.\n", filename);
al_destroy_path(video->filename);
al_free(video);
return NULL;
}
al_init_user_event_source(&video->es);
video->es_inited = true;
return video;
}
void rebuild_encoder(xmlrpc_c::paramList const& paramList, xmlrpc_c::value* retvalP) {
ACE_TRACE("modRSEncode_Interface::rebuild_encoder");
find_handler(paramList)->rebuildEncoder();
*retvalP = xmlrpc_c::value_nil();
}
/***********************************************************************
* process_events
*/
static int process_events( Display *display, ULONG_PTR mask )
{
XEvent event;
HWND hwnd;
int count = 0;
x11drv_event_handler handler;
wine_tsx11_lock();
while (XCheckIfEvent( display, &event, filter_event, (char *)mask ))
{
count++;
if (XFilterEvent( &event, None )) continue; /* filtered, ignore it */
if (!(handler = find_handler( event.type )))
{
TRACE( "%s, ignoring\n", dbgstr_event( event.type ));
continue; /* no handler, ignore it */
}
if (XFindContext( display, event.xany.window, winContext, (char **)&hwnd ) != 0)
hwnd = 0; /* not for a registered window */
if (!hwnd && event.xany.window == root_window) hwnd = GetDesktopWindow();
wine_tsx11_unlock();
TRACE( "%s for hwnd/window %p/%lx\n",
dbgstr_event( event.type ), hwnd, event.xany.window );
handler( hwnd, &event );
wine_tsx11_lock();
}
XFlush( gdi_display );
wine_tsx11_unlock();
if (count) TRACE( "processed %d events\n", count );
return count;
}
int KSGDevice::ExecuteTask(DeviceNodeType* node,Task* task)
{
// 检查是否支持指令
DI * devintr = FindDevInterface(task->GetTaskCode());
if(!devintr)
{
throw TaskNotSupportedException();
}
//
int ret;
ACE_HANDLE handler;
ret = find_handler(node,&handler);
if(ret)
{
ACE_DEBUG((LM_ERROR,"连接指定设备失败!"));
return TASK_ERR_CONNECT;
}
// 执行指令
try
{
task->_handle = handler;
ret = devintr->ExecuteTask(node,task);
}
catch(...)
{
// ignore
}
// 如果指令执行超时,关闭连接
if(release_handler(node,&handler,ret != TASK_SUCCESS))
{
ACE_DEBUG((LM_ERROR,"释放连接失败"));
}
return ret;
}
static int
UdpAliasOut(struct libalias *la, struct ip *pip, int create)
{
struct udphdr *ud;
struct alias_link *lnk;
int error;
LIBALIAS_LOCK_ASSERT(la);
/* Return if proxy-only mode is enabled */
if (la->packetAliasMode & PKT_ALIAS_PROXY_ONLY)
return (PKT_ALIAS_OK);
ud = (struct udphdr *)ip_next(pip);
lnk = FindUdpTcpOut(la, pip->ip_src, pip->ip_dst,
ud->uh_sport, ud->uh_dport,
IPPROTO_UDP, create);
if (lnk != NULL) {
u_short alias_port;
struct in_addr alias_address;
struct alias_data ad;
ad.lnk = lnk;
ad.oaddr = NULL;
ad.aaddr = &alias_address;
ad.aport = &alias_port;
ad.sport = &ud->uh_sport;
ad.dport = &ud->uh_dport;
ad.maxpktsize = 0;
alias_address = GetAliasAddress(lnk);
alias_port = GetAliasPort(lnk);
/* Walk out chain. */
error = find_handler(OUT, UDP, la, pip, &ad);
/* If UDP checksum is not zero, adjust since source port is */
/* being aliased and source address is being altered */
if (ud->uh_sum != 0) {
int accumulate;
accumulate = ud->uh_sport;
accumulate -= alias_port;
accumulate += twowords(&pip->ip_src);
accumulate -= twowords(&alias_address);
ADJUST_CHECKSUM(accumulate, ud->uh_sum);
}
/* Put alias port in UDP header */
ud->uh_sport = alias_port;
/* Change source address */
DifferentialChecksum(&pip->ip_sum,
&alias_address, &pip->ip_src, 2);
pip->ip_src = alias_address;
return (PKT_ALIAS_OK);
}
return (PKT_ALIAS_IGNORED);
}
PUBLIC
bool
Jdb_kobject::handle_obj(Kobject *o, int lvl)
{
if (Jdb_kobject_handler *h = find_handler(o))
return h->show_kobject(o, lvl);
return true;
}
int
parse_cmd (char * cmd, char ** reply, int * len, void * data, int timeout )
{
int r;
struct handler * h;
vector cmdvec = NULL;
struct timespec tmo;
r = get_cmdvec(cmd, &cmdvec);
if (r) {
*reply = genhelp_handler(cmd, r);
*len = strlen(*reply) + 1;
return 0;
}
h = find_handler(fingerprint(cmdvec));
if (!h || !h->fn) {
*reply = genhelp_handler(cmd, EINVAL);
*len = strlen(*reply) + 1;
free_keys(cmdvec);
return 0;
}
/*
* execute handler
*/
if (clock_gettime(CLOCK_MONOTONIC, &tmo) == 0) {
tmo.tv_sec += timeout;
} else {
tmo.tv_sec = 0;
}
if (h->locked) {
int locked = 0;
struct vectors * vecs = (struct vectors *)data;
pthread_cleanup_push(cleanup_lock, &vecs->lock);
if (tmo.tv_sec) {
r = timedlock(&vecs->lock, &tmo);
} else {
lock(&vecs->lock);
r = 0;
}
if (r == 0) {
locked = 1;
pthread_testcancel();
r = h->fn(cmdvec, reply, len, data);
}
pthread_cleanup_pop(locked);
} else
r = h->fn(cmdvec, reply, len, data);
free_keys(cmdvec);
return r;
}
int
set_handler_callback (unsigned long fp, int (*fn)(void *, char **, int *, void *))
{
struct handler * h = find_handler(fp);
if (!h)
return 1;
h->fn = fn;
return 0;
}
//---------------------------------------------------------------------------------------
void Observer::remove_old_handler(int eventType)
{
std::list<EventCallback*>::iterator it = find_handler(eventType);
if (it != m_handlers.end())
{
EventCallback* pCB = *it;
m_handlers.erase(it);
delete pCB;
}
}
int
set_handler_callback (uint64_t fp, int (*fn)(void *, char **, int *, void *))
{
struct handler * h = find_handler(fp);
if (!h)
return 1;
h->fn = fn;
h->locked = 1;
return 0;
}
int vsavefile(char *newfilename ){
imageHandler *ih;
int handleno = 0;
handleno = find_handler(newfilename);
if( handleno == -1){
printf(" We cannot handle this kind of files\n");
return FALSE;
}
ih=imagehandlers[handleno];
ih->savefile(newfilename);
}
int vdrawImage(char *filename){
imageHandler *ih;
int handleno = 0;
handleno = find_handler(filename);
printf(" handle no = %d\n", handleno);
if( handleno == -1){
printf(" We cannot handle this kind of files\n");
return FALSE;
}
ih=imagehandlers[handleno];
ih->drawImage(filename);
return FALSE;
}
static int call_handler(struct rtnl_handle *rtnl_handle,
u_int16_t type,
struct nlmsghdr *hdr)
{
struct rtnl_handler *h = find_handler(rtnl_handle, type);
if (!h) {
rtnl_log(LOG_DEBUG, "no registered handler for type %u", type);
return 0;
}
return (h->handlefn)(hdr, h->arg);
}
void set_fill_pattern(xmlrpc_c::paramList const& paramList, xmlrpc_c::value* retvalP) {
ACE_TRACE("modTM_VC_Gen_Packet_Interface::set_fill_pattern");
const std::vector<xmlrpc_c::value> xml_rpc_pattern = paramList.getArray(2);
std::vector<uint8_t> fillPattern;
for (unsigned i = 0; i < xml_rpc_pattern.size(); i++ ) {
fillPattern[i] = xmlrpc_c::value_int(xml_rpc_pattern[i]);
}
find_handler(paramList)->setFillPattern(fillPattern);
*retvalP = xmlrpc_c::value_nil();
}
void get_fill_pattern(xmlrpc_c::paramList const& paramList, xmlrpc_c::value* retvalP) {
ACE_TRACE("modTM_VC_Gen_Packet_Interface::get_fill_pattern");
std::vector<uint8_t> fillPattern;
find_handler(paramList)->getFillPattern(fillPattern);
std::vector<xmlrpc_c::value> xml_rpc_pattern;
for (unsigned i = 0; i < fillPattern.size(); i++ ) {
xml_rpc_pattern[i] = xmlrpc_c::value_int(fillPattern[i]);
}
*retvalP = xmlrpc_c::value_array(xml_rpc_pattern);
}
void
maybe_start_try (int start_pc, int end_pc)
{
struct eh_range *range;
if (! doing_eh ())
return;
range = find_handler (start_pc);
while (range != NULL_EH_RANGE && range->start_pc == start_pc
&& range->end_pc < end_pc)
range = range->outer;
current_range = range;
check_start_handlers (range, start_pc);
}
//////////////////////////////////////////////////////////////////////////
// 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;
}
int KSGDevice::ExecuteTask(DeviceNodeType* node,Task* task)
{
// 检查是否支持指令
bool free_conn = false;
DI devintr = FindDevInterface(task->GetTaskCode());
if(!devintr)
{
throw TaskNotSupportedException();
}
//
int ret;
ACE_HANDLE handler;
ret = find_handler(node,&handler);
if(ret)
{
ACE_DEBUG((LM_ERROR,"连接指定设备失败!"));
return TASK_ERR_CONNECT;
}
// 执行指令
try
{
task->_handle = handler;
ret = devintr->ExecuteTask(node,task);
}
catch(...)
{
// ignore
}
// 如果指令执行超时,关闭连接
if(node->connect_module() == KSGDeviceNode::cm_short_conn
|| ret != TASK_SUCCESS)
{
free_conn = true;
}
try
{
if(release_handler(node,&handler,free_conn))
{
ACE_DEBUG((LM_ERROR,"释放连接失败"));
}
}
catch (...)
{
ACE_DEBUG((LM_ERROR,"关闭连接异常!"));
}
return ret;
}
virtual void set_rate_limit(xmlrpc_c::paramList const& paramList, xmlrpc_c::value* retvalP) {
ACE_TRACE("modEmulateRate_Interface::set_rate");
int rate = 0, startTime = -1.0;
if ( paramList[2].type() != xmlrpc_c::value::TYPE_ARRAY ) {
rate = paramList.getInt(2);
}
else {
const std::vector<xmlrpc_c::value> arrayData = paramList.getArray(2);
startTime = xmlrpc_c::value_double(arrayData[0]);
rate = xmlrpc_c::value_double(arrayData[1]);
}
find_handler(paramList)->setRateLimit(rate, startTime);
*retvalP = xmlrpc_c::value_nil();
}
static void parse_listener(struct config *c, struct config_line *l,
struct lwan *lwan)
{
free(lwan->config.listener);
lwan->config.listener = strdup(l->value);
while (config_read_line(c, l)) {
switch (l->type) {
case CONFIG_LINE_TYPE_LINE:
config_error(c, "Expecting prefix section");
return;
case CONFIG_LINE_TYPE_SECTION:
if (streq(l->key, "prefix")) {
parse_listener_prefix(c, l, lwan, NULL, NULL);
continue;
}
if (l->key[0] == '&') {
l->key++;
void *handler = find_handler(l->key);
if (handler) {
parse_listener_prefix(c, l, lwan, NULL, handler);
continue;
}
config_error(c, "Could not find handler name: %s", l->key);
return;
}
const struct lwan_module *module = find_module(l->key);
if (module) {
parse_listener_prefix(c, l, lwan, module, NULL);
continue;
}
config_error(c, "Invalid section or module not found: %s", l->key);
return;
case CONFIG_LINE_TYPE_SECTION_END:
return;
}
}
config_error(c, "Expecting section end while parsing listener");
}
unsigned int avctp_register_pdu_handler(uint8_t opcode, avctp_pdu_cb cb,
void *user_data)
{
struct avctp_pdu_handler *handler;
static unsigned int id = 0;
handler = find_handler(handlers, opcode);
if (handler)
return 0;
handler = g_new(struct avctp_pdu_handler, 1);
handler->opcode = opcode;
handler->cb = cb;
handler->user_data = user_data;
handler->id = ++id;
handlers = g_slist_append(handlers, handler);
return handler->id;
}
static void handle_input_line(shell_t *shell, char* line) {
char* saveptr;
char* linedup = strdup(line);
char* command = strtok_r(linedup, " ", &saveptr);
void (*handler)(char*) = NULL;
if (command) {
handler = find_handler(shell->command_list, command);
if (handler != NULL) {
handler(line);
} else {
if ( strcmp("help", command) == 0) {
print_help(shell->command_list);
} else {
puts("shell: command not found.");
}
}
}
free(linedup);
}
int KSGDevice::ExecuteTask(DeviceNodeType* node,Task* task)
{
// 检查是否支持指令
bool free_conn = false;
DI devintr = FindDevInterface(task->GetTaskCode());
if(!devintr)
{
ACE_DEBUG((LM_ERROR,"设备不支持该指令..."));
throw TaskNotSupportedException();
}
//
int ret;
ACE_HANDLE handler;
ret = find_handler(node,&handler);
if(ret)
{
ACE_DEBUG((LM_ERROR,"连接指定设备失败!"));
return TASK_ERR_CONNECT;
}
// 执行指令
try
{
task->_handle = handler;
ret = devintr->ExecuteTask(node,task);
}
catch(...)
{
// ignore
}
if(node->connect_module() == KSGDeviceNode::cm_short_conn)
{
free_conn = true;
}
// 如果指令执行不成功
else
{
//
if(ret != TASK_SUCCESS)
{
if(ret == TASK_ERR_TIMEOUT)
free_conn = true;
else
{
ACE_Time_Value tv(1);
int res = ACE::handle_exception_ready(task->_handle,&tv);
if(res >0)
{
// 如果发生异常，则重连
free_conn = true;
}
else if(res == 0) // 超时
{
free_conn = true;
}
else // 返回错误
{
}
}
}
}
try
{
if(release_handler(node,&handler,free_conn))
{
ACE_DEBUG((LM_ERROR,"释放连接失败"));
}
}
catch (...)
{
ACE_DEBUG((LM_ERROR,"关闭连接异常!"));
}
return ret;
}
static gboolean session_cb(GIOChannel *chan, GIOCondition cond,
gpointer data)
{
struct avctp *session = data;
struct avctp_channel *control = session->control;
uint8_t *buf = control->buffer;
uint8_t *operands, code, subunit;
struct avctp_header *avctp;
struct avc_header *avc;
int ret, packet_size, operand_count, sock;
struct avctp_pdu_handler *handler;
if (cond & (G_IO_ERR | G_IO_HUP | G_IO_NVAL))
goto failed;
sock = g_io_channel_unix_get_fd(chan);
ret = read(sock, buf, control->imtu);
if (ret <= 0)
goto failed;
if ((unsigned int) ret < sizeof(struct avctp_header)) {
error("Too small AVCTP packet");
goto failed;
}
avctp = (struct avctp_header *) buf;
ret -= sizeof(struct avctp_header);
if ((unsigned int) ret < sizeof(struct avc_header)) {
error("Too small AVCTP packet");
goto failed;
}
avc = (struct avc_header *) (buf + sizeof(struct avctp_header));
ret -= sizeof(struct avc_header);
operands = buf + sizeof(struct avctp_header) + sizeof(struct avc_header);
operand_count = ret;
if (avctp->cr == AVCTP_RESPONSE) {
control_response(control, avctp, avc, operands, operand_count);
return TRUE;
}
packet_size = AVCTP_HEADER_LENGTH + AVC_HEADER_LENGTH;
avctp->cr = AVCTP_RESPONSE;
if (avctp->packet_type != AVCTP_PACKET_SINGLE) {
avc->code = AVC_CTYPE_NOT_IMPLEMENTED;
goto done;
}
if (avctp->pid != htons(AV_REMOTE_SVCLASS_ID)) {
avctp->ipid = 1;
packet_size = AVCTP_HEADER_LENGTH;
goto done;
}
handler = find_handler(control->handlers, avc->opcode);
if (!handler) {
DBG("handler not found for 0x%02x", avc->opcode);
packet_size += avrcp_handle_vendor_reject(&code, operands);
avc->code = code;
goto done;
}
code = avc->code;
subunit = avc->subunit_type;
packet_size += handler->cb(session, avctp->transaction, &code,
&subunit, operands, operand_count,
handler->user_data);
avc->code = code;
avc->subunit_type = subunit;
done:
ret = write(sock, buf, packet_size);
if (ret != packet_size)
goto failed;
return TRUE;
failed:
DBG("AVCTP session %p got disconnected", session);
avctp_set_state(session, AVCTP_STATE_DISCONNECTED);
return FALSE;
}
