void AddDialog::accept()
{
mFr.base.proto = get_proto(ui->cbProto->currentText().toStdString().c_str());
mFr.base.src_port = ui->leSourcePort->text().toUInt();
bool any = ui->rbAnyone->isChecked();
QHostAddress hostaddr(any?"0.0.0.0":ui->leSourceHostIP->text());
if( hostaddr.isNull() )
{
/*QMessageBox::StandardButton reply =*/ QMessageBox::critical(this, tr("Data error")
, tr("Wrong ip address")
, QMessageBox::Ok );
}
else if( mFr.base.src_port==0 )
{
/*QMessageBox::StandardButton reply =*/ QMessageBox::critical(this, tr("Data error")
, tr("Wrong port number")
, QMessageBox::Ok );
}
else
{
mFr.base.s_addr.addr = static_cast<quint32>(htonl(hostaddr.toIPv4Address()));
emit accept_rule(mFr);
QDialog::accept();
}
}
// for optimization I don't want to put '__constructor__' into as_object
// so the missing of '__constructor__' in a object means
// that it is a instance of as_object
bool as_object::is_instance_of(const as_function* constructor) const
{
// by default ctor is as_global_object_ctor
as_value ctor;
get_ctor(&ctor);
if (ctor.is_undefined())
{
ctor.set_as_c_function(as_global_object_ctor);
}
const as_s_function* sf = cast_to<as_s_function>(constructor);
if (sf && sf == cast_to<as_s_function>(ctor.to_function()))
{
return true;
}
const as_c_function* cf1 = cast_to<as_c_function>(constructor);
const as_c_function* cf2 = cast_to<as_c_function>(ctor.to_function());
if (cf1 && cf2 && cf1->m_func == cf2->m_func)
{
return true;
}
as_object* proto = get_proto();
if (proto)
{
return proto->is_instance_of(constructor);
}
return false;
}
unsigned
pgp_key_size(pgp_symm_alg_t alg)
{
const pgp_crypt_t *p = get_proto(alg);
return (p == NULL) ? 0 : (unsigned)p->keysize;
}
bool as_object::get_member(const tu_stringi& name, as_value* val)
{
//printf("GET MEMBER: %s at %p for object %p\n", name.c_str(), val, this);
// first try built-ins object methods
if (get_builtin(BUILTIN_OBJECT_METHOD, name, val))
{
return true;
}
if (m_members.get(name, val) == false)
{
as_object* proto = get_proto();
if (proto == NULL)
{
return false;
}
if (proto->get_member(name, val) == false)
{
return false;
}
}
if (val->is_property())
{
val->set_property_target(this);
}
return true;
}
unsigned
__ops_key_size(__ops_symm_alg_t alg)
{
const __ops_crypt_t *p = get_proto(alg);
return (p == NULL) ? 0 : (unsigned)p->keysize;
}
/*
* M A I N
*
*/
int
main(int argc, char **argv)
{
char *prototype; /* Contains full text of prototype document */
char proto_file[256] = {0};
FILE *table;
char table_file[256] = {0};
if ( argc < 2 || argc > 3 ) {
fprintf(stderr, "Usage: tabsub prototype_file [table_file]\n");
bu_exit(12, NULL);
}
bu_strlcpy(proto_file, argv[1], sizeof(proto_file));
/* Acquire in-core copy of prototype file */
get_proto( &prototype, proto_file );
if ( argc < 3 ) {
table = stdin;
} else {
bu_strlcpy(table_file, argv[2], sizeof(table_file));
if ( (table = fopen( table_file, "r" )) == NULL ) {
perror( table_file );
bu_exit(3, NULL);
}
}
do_lines( table, prototype );
return 0;
}
/*
* MPID_Probe
*/
void MPID_Probe(struct MPIR_COMMUNICATOR *comm,
int tag,
int context_id,
int src_lrank,
int *error_code,
MPI_Status *status)
{
int found = 0;
*error_code = 0;
# if defined(VMPI)
{
int proto = get_proto(comm, src_lrank);
if (proto == mpi)
{
void * vmpi_status;
int vmpi_src;
int vmpi_tag;
vmpi_status = STATUS_INFO_GET_VMPI_PTR(*status);
if (src_lrank == MPI_ANY_SOURCE)
{
vmpi_src = VMPI_ANY_SOURCE;
}
else
{
vmpi_src = comm->lrank_to_vlrank[src_lrank];
}
vmpi_tag = (tag == MPI_ANY_TAG ? VMPI_ANY_TAG : tag);
*error_code = vmpi_error_to_mpich_error(
mp_probe(vmpi_src, vmpi_tag, comm->vmpi_comm, vmpi_status));
status->MPI_SOURCE = comm->vlrank_to_lrank[
mp_status_get_source(vmpi_status)];
status->MPI_TAG = mp_status_get_tag(vmpi_status);
status->MPI_ERROR = *error_code;
STATUS_INFO_SET_COUNT_VMPI(*status);
return;
}
}
# endif /* defined(VMPI) */
while (*error_code == 0 && !found)
{
MPID_Iprobe(comm,
tag,
context_id,
src_lrank,
&found,
error_code,
status);
} /* endwhile */
} /* end MPID_Probe() */
static int l_deepactivelines(lua_State *L) {
luaL_checktype(L, 1, LUA_TFUNCTION);
luaL_argcheck(L, !lua_iscfunction(L, 1), 1,
"Lua function expected, got C function");
lua_settop(L, 1);
lua_newtable(L);
add_activelines(L, get_proto(L));
return 1;
}
int
pgp_crypt_any(pgp_crypt_t *crypt, pgp_symm_alg_t alg)
{
const pgp_crypt_t *ptr = get_proto(alg);
if (ptr) {
*crypt = *ptr;
return 1;
} else {
(void) memset(crypt, 0x0, sizeof(*crypt));
return 0;
}
}
static inline void uih_frame(int level, struct frame *frm, long_frame_head *head)
{
uint32_t proto;
if (!head->addr.server_chn) {
mcc_frame(level, frm, head);
} else {
p_indent(level, frm);
printf("RFCOMM(d): UIH: ");
print_rfcomm_hdr(head, frm->ptr, frm->len);
if (GET_PF(head->control)) {
printf("credits %d\n", *(uint8_t *)(frm->ptr));
frm->ptr++;
frm->len--;
} else
printf("\n");
frm->len--;
frm->dlci = GET_DLCI(head->addr);
frm->channel = head->addr.server_chn;
proto = get_proto(frm->handle, RFCOMM_PSM, frm->channel);
if (frm->len > 0) {
switch (proto) {
case SDP_UUID_OBEX:
if (!p_filter(FILT_OBEX))
obex_dump(level + 1, frm);
else
raw_dump(level, frm);
break;
case SDP_UUID_LAN_ACCESS_PPP:
case SDP_UUID_DIALUP_NETWORKING:
if (!p_filter(FILT_PPP))
ppp_dump(level + 1, frm);
else
raw_dump(level, frm);
break;
default:
if (p_filter(FILT_RFCOMM))
break;
raw_dump(level, frm);
break;
}
}
}
}
/*
* This returns all the pointer-bearing registers whose pointees :insn will
* read from.
*/
std::vector<uint16_t> object_read_registers(const IRInstruction* insn) {
switch (insn->opcode()) {
case OPCODE_AGET:
case OPCODE_AGET_WIDE:
case OPCODE_AGET_BOOLEAN:
case OPCODE_AGET_BYTE:
case OPCODE_AGET_CHAR:
case OPCODE_AGET_SHORT:
case OPCODE_AGET_OBJECT:
case OPCODE_IGET:
case OPCODE_IGET_WIDE:
case OPCODE_IGET_BOOLEAN:
case OPCODE_IGET_BYTE:
case OPCODE_IGET_CHAR:
case OPCODE_IGET_SHORT:
case OPCODE_IGET_OBJECT:
case OPCODE_APUT_OBJECT:
case OPCODE_IPUT_OBJECT:
case OPCODE_SPUT_OBJECT:
case OPCODE_RETURN_OBJECT:
return {insn->src(0)};
case OPCODE_INVOKE_SUPER:
case OPCODE_INVOKE_DIRECT:
case OPCODE_INVOKE_STATIC:
case OPCODE_INVOKE_VIRTUAL:
case OPCODE_INVOKE_INTERFACE: {
std::vector<uint16_t> regs;
size_t idx{0};
if (insn->opcode() != OPCODE_INVOKE_STATIC) {
// The `this` parameter
regs.emplace_back(insn->src(idx++));
}
auto callee = insn->get_method();
auto arg_types = callee->get_proto()->get_args()->get_type_list();
for (DexType* arg_type : arg_types) {
if (!is_primitive(arg_type)) {
regs.emplace_back(insn->src(idx));
}
++idx;
}
return regs;
}
default:
return {};
}
}
void exclude_referenced_bridgee(DexMethod* code_method, IRCode& code) {
for (auto& mie : InstructionIterable(&code)) {
auto inst = mie.insn;
if (!is_invoke(inst->opcode())) continue;
auto method = inst->get_method();
auto range = m_potential_bridgee_refs.equal_range(
MethodRef(method->get_class(), method->get_name(),
method->get_proto()));
for (auto it = range.first; it != range.second; ++it) {
auto referenced_bridge = it->second;
// Don't count the bridge itself
if (referenced_bridge == code_method) continue;
TRACE(BRIDGE,
5,
"Rejecting, reference `%s.%s.%s' in `%s' blocks `%s'\n",
SHOW(method->get_class()),
SHOW(method->get_name()),
SHOW(method->get_proto()),
SHOW(code_method),
SHOW(referenced_bridge));
m_bridges_to_bridgees.erase(referenced_bridge);
}
}
}
void exclude_referenced_bridgee(DexMethod* code_method, const DexCode& code) {
auto const& insts = code.get_instructions();
for (auto inst : insts) {
if (!is_invoke(inst->opcode())) continue;
auto method = static_cast<DexOpcodeMethod*>(inst)->get_method();
auto range = m_potential_bridgee_refs.equal_range(
MethodRef(method->get_class(), method->get_name(),
method->get_proto()));
for (auto it = range.first; it != range.second; ++it) {
auto referenced_bridge = it->second;
// Don't count the bridge itself
if (referenced_bridge == code_method) continue;
TRACE(BRIDGE,
5,
"Rejecting, reference `%s.%s.%s' in `%s' blocks `%s'\n",
SHOW(method->get_class()),
SHOW(method->get_name()),
SHOW(method->get_proto()),
SHOW(code_method),
SHOW(referenced_bridge));
m_bridges_to_bridgees.erase(referenced_bridge);
}
}
}
/**
* Change the visibility of members accessed in a callee as they are moved
* to the caller context.
* We make everything public but we could be more precise and only
* relax visibility as needed.
*/
void MultiMethodInliner::change_visibility(DexMethod* callee) {
TRACE(MMINL, 6, "checking visibility usage of members in %s\n",
SHOW(callee));
for (auto insn : callee->get_code()->get_instructions()) {
if (insn->has_fields()) {
auto fop = static_cast<DexOpcodeField*>(insn);
auto field = fop->field();
field = resolve_field(field, is_sfield_op(insn->opcode())
? FieldSearch::Static : FieldSearch::Instance);
if (field != nullptr && field->is_concrete()) {
TRACE(MMINL, 6, "changing visibility of %s.%s %s\n",
SHOW(field->get_class()), SHOW(field->get_name()),
SHOW(field->get_type()));
set_public(field);
set_public(type_class(field->get_class()));
fop->rewrite_field(field);
}
continue;
}
if (insn->has_methods()) {
auto mop = static_cast<DexOpcodeMethod*>(insn);
auto method = mop->get_method();
method = resolver(method, opcode_to_search(insn));
if (method != nullptr && method->is_concrete()) {
TRACE(MMINL, 6, "changing visibility of %s.%s: %s\n",
SHOW(method->get_class()), SHOW(method->get_name()),
SHOW(method->get_proto()));
set_public(method);
set_public(type_class(method->get_class()));
mop->rewrite_method(method);
}
continue;
}
if (insn->has_types()) {
auto type = static_cast<DexOpcodeType*>(insn)->get_type();
auto cls = type_class(type);
if (cls != nullptr && !cls->is_external()) {
TRACE(MMINL, 6, "changing visibility of %s\n", SHOW(type));
set_public(cls);
}
continue;
}
}
}
/**
* If the caller is in the primary DEX we want to make sure there are no
* references in other DEXes that may cause a verification error.
* Don't inline if so.
*/
bool MultiMethodInliner::refs_not_in_primary(DexMethod* callee) {
const auto ok_from_primary = [&](DexType* type) {
if (primary.count(type) == 0 && type_class_internal(type) != nullptr) {
info.not_in_primary++;
return false;
}
return true;
};
for (auto insn : callee->get_code()->get_instructions()) {
if (insn->has_types()) {
auto top = static_cast<DexOpcodeType*>(insn);
if (!ok_from_primary(top->get_type())) {
return true;
}
} else if (insn->has_methods()) {
auto mop = static_cast<DexOpcodeMethod*>(insn);
auto meth = mop->get_method();
if (!ok_from_primary(meth->get_class())) {
return true;
}
auto proto = meth->get_proto();
if (!ok_from_primary(proto->get_rtype())) {
return true;
}
auto args = proto->get_args();
if (args == nullptr) continue;
for (const auto& arg : args->get_type_list()) {
if (!ok_from_primary(arg)) {
return true;
}
}
} else if (insn->has_fields()) {
auto fop = static_cast<DexOpcodeField*>(insn);
auto field = fop->field();
if (!ok_from_primary(field->get_class()) ||
!ok_from_primary(field->get_type())) {
return true;
}
}
}
return false;
}
TEST_F(PreVerify, InlineInvokeDirect) {
auto cls = find_class_named(
classes, "Lcom/facebook/redexinline/InlineTest;");
auto m = find_vmethod_named(*cls, "testInlineInvokeDirect");
auto invoke =
find_invoke(m, OPCODE_INVOKE_DIRECT, "hasNoninlinableInvokeDirect");
auto noninlinable_invoke_direct =
find_invoke(invoke->get_method(), OPCODE_INVOKE_DIRECT, "noninlinable");
auto noninlinable = noninlinable_invoke_direct->get_method();
ASSERT_EQ(show(noninlinable->get_proto()), "()V");
// verify that there are two inlinable() methods in the class. The static
// version exists to test that we don't cause a signature collision when we
// make the instance method static.
auto dmethods = cls->get_dmethods();
ASSERT_EQ(2,
std::count_if(dmethods.begin(), dmethods.end(), [](DexMethod* m) {
return !strcmp("noninlinable", m->get_name()->c_str());
}));
}
TEST_F(PostVerify, InlineInvokeDirect) {
auto cls = find_class_named(
classes, "Lcom/facebook/redexinline/InlineTest;");
auto m = find_vmethod_named(*cls, "testInlineInvokeDirect");
auto noninlinable_invoke_direct =
find_invoke(m, OPCODE_INVOKE_STATIC, "noninlinable$redex0");
ASSERT_NE(nullptr, noninlinable_invoke_direct);
auto noninlinable = noninlinable_invoke_direct->get_method();
ASSERT_EQ(show(noninlinable->get_proto()),
"(Lcom/facebook/redexinline/InlineTest;)V");
auto dmethods = cls->get_dmethods();
// verify that we've replaced the instance noninlinable() method with
// noninlinable$redex
ASSERT_EQ(1,
std::count_if(dmethods.begin(), dmethods.end(), [](DexMethod* m) {
return !strcmp("noninlinable", m->get_name()->c_str());
}));
ASSERT_EQ(1,
std::count_if(dmethods.begin(), dmethods.end(), [](DexMethod* m) {
return !strcmp("noninlinable$redex0", m->get_name()->c_str());
}));
}
bool as_object::find_property( const tu_stringi & name, as_value * val )
{
as_value dummy;
if( get_member(name, &dummy) )
{
val->set_as_object( this );
return true;
}
if(m_instance.get_ptr() != NULL)
{
// create traits
for (int i = 0; i < m_instance->m_trait.size(); i++)
{
traits_info* ti = m_instance->m_trait[i].get();
const char* traits_name = m_instance->m_abc->get_multiname(ti->m_name);
if( name == traits_name)
{
if(ti->m_kind == traits_info::Trait_Slot)
{
val->set_as_object( this );
return true;
}
return false;
}
}
}
as_object *proto = get_proto();
if( proto )
{
return proto->find_property( name, val );
}
return false;
}
nsapi_error_t Socket::open(NetworkStack *stack)
{
_lock.lock();
if (_stack != NULL || stack == NULL) {
_lock.unlock();
return NSAPI_ERROR_PARAMETER;
}
_stack = stack;
nsapi_socket_t socket;
nsapi_error_t err = _stack->socket_open(&socket, get_proto());
if (err) {
_lock.unlock();
return err;
}
_socket = socket;
_event.attach(this, &Socket::event);
_stack->socket_attach(_socket, Callback<void()>::thunk, &_event);
_lock.unlock();
return NSAPI_ERROR_OK;
}
/* WARNING: doesn't work from failure route (deadlock, uses t_reply => tries
* to get the reply lock again */
int t_relay_to( struct sip_msg *p_msg , struct proxy_l *proxy, int proto,
int replicate)
{
int ret;
int new_tran;
/* struct hdr_field *hdr; */
struct cell *t;
struct dest_info dst;
unsigned short port;
str host;
short comp;
#ifndef TM_DELAYED_REPLY
int reply_ret;
#endif
ret=0;
/* special case for CANCEL */
if ( p_msg->REQ_METHOD==METHOD_CANCEL){
ret=t_forward_cancel(p_msg, proxy, proto, &t);
if (t) goto handle_ret;
goto done;
}
new_tran = t_newtran( p_msg );
/* parsing error, memory alloc, whatever ... if via is bad
and we are forced to reply there, return with 0 (->break),
pass error status otherwise
MMA: return value E_SCRIPT means that transaction was already started
from the script so continue with that transaction
*/
if (likely(new_tran!=E_SCRIPT)) {
if (new_tran<0) {
ret = (ser_error==E_BAD_VIA && reply_to_via) ? 0 : new_tran;
goto done;
}
/* if that was a retransmission, return we are happily done */
if (new_tran==0) {
ret = 1;
goto done;
}
}else if (unlikely(p_msg->REQ_METHOD==METHOD_ACK)) {
/* transaction previously found (E_SCRIPT) and msg==ACK
=> ack to neg. reply or ack to local trans.
=> process it and exit */
/* FIXME: there's no way to distinguish here between acks to
local trans. and neg. acks */
/* in normal operation we should never reach this point, if we
do WARN(), it might hide some real bug (apart from possibly
hiding a bug the most harm done is calling the TMCB_ACK_NEG
callbacks twice) */
WARN("negative or local ACK caught, please report\n");
t=get_t();
if (unlikely(has_tran_tmcbs(t, TMCB_ACK_NEG_IN)))
run_trans_callbacks(TMCB_ACK_NEG_IN, t, p_msg, 0,
p_msg->REQ_METHOD);
t_release_transaction(t);
ret=1;
goto done;
}
/* new transaction */
/* at this point if the msg is an ACK it is an e2e ACK and
e2e ACKs do not establish a transaction and are fwd-ed statelessly */
if ( p_msg->REQ_METHOD==METHOD_ACK) {
DBG( "SER: forwarding ACK statelessly \n");
if (proxy==0) {
init_dest_info(&dst);
dst.proto=proto;
if (get_uri_send_info(GET_NEXT_HOP(p_msg), &host, &port,
&dst.proto, &comp)!=0){
ret=E_BAD_ADDRESS;
goto done;
}
#ifdef USE_COMP
dst.comp=comp;
#endif
/* dst->send_sock not set, but forward_request will take care
* of it */
ret=forward_request(p_msg, &host, port, &dst);
} else {
init_dest_info(&dst);
dst.proto=get_proto(proto, proxy->proto);
proxy2su(&dst.to, proxy);
/* dst->send_sock not set, but forward_request will take care
* of it */
ret=forward_request( p_msg , 0, 0, &dst) ;
}
goto done;
}
/* if replication flag is set, mark the transaction as local
so that replies will not be relayed */
t=get_t();
if (replicate) t->flags|=T_IS_LOCAL_FLAG;
/* INVITE processing might take long, particularly because of DNS
look-ups -- let upstream know we're working on it */
if (p_msg->REQ_METHOD==METHOD_INVITE && (t->flags&T_AUTO_INV_100)
&& (t->uas.status < 100)
) {
DBG( "SER: new INVITE\n");
if (!t_reply( t, p_msg , 100 ,
cfg_get(tm, tm_cfg, tm_auto_inv_100_r)))
DBG("SER: ERROR: t_reply (100)\n");
}
/* now go ahead and forward ... */
ret=t_forward_nonack(t, p_msg, proxy, proto);
handle_ret:
if (ret<=0) {
DBG( "t_forward_nonack returned error %d (%d)\n", ret, ser_error);
/* we don't want to pass upstream any reply regarding replicating
* a request; replicated branch must stop at us*/
if (likely(!replicate)) {
if(t->flags&T_DISABLE_INTERNAL_REPLY) {
/* flag set to don't generate the internal negative reply
* - let the transaction live further, processing should
* continue in config */
DBG("not generating immediate reply for error %d\n", ser_error);
tm_error=ser_error;
ret = -4;
goto done;
}
#ifdef TM_DELAYED_REPLY
/* current error in tm_error */
tm_error=ser_error;
set_kr(REQ_ERR_DELAYED);
DBG("%d error reply generation delayed \n", ser_error);
#else
reply_ret=kill_transaction( t, ser_error );
if (reply_ret>0) {
/* we have taken care of all -- do nothing in
script */
DBG("ERROR: generation of a stateful reply "
"on error succeeded\n");
/*ret=0; -- we don't want to stop the script */
} else {
DBG("ERROR: generation of a stateful reply "
"on error failed\n");
t_release_transaction(t);
}
#endif /* TM_DELAYED_REPLY */
}else{
t_release_transaction(t); /* kill it silently */
}
} else {
DBG( "SER: new transaction fwd'ed\n");
}
done:
return ret;
}
static int
filter6_parser(char *cmdbuf)
{
char w[MAX_WORD], *cp = cmdbuf;
char *ifname, class_name[MAX_WORD], fltr_name[MAX_WORD];
char *flname = NULL;
struct flow_filter6 sfilt;
int protocol;
u_char tclass, tclassmask;
int ruleno;
int dontwarn = 0;
int ret;
memset(&sfilt, 0, sizeof(sfilt));
sfilt.ff_flow6.fi6_family = AF_INET6;
if (!get_ifname(&cp, &ifname)) {
LOG(LOG_ERR, 0, "missing interface name");
return (0);
}
if (!next_word(&cp, class_name)) {
LOG(LOG_ERR, 0, "missing class name");
return (0);
}
fltr_name[0] = '\0';
ruleno = 0;
if (!get_fltr_opts(&cp, &fltr_name[0], sizeof(fltr_name), &ruleno)) {
LOG(LOG_ERR, 0, "bad filter option");
return (0);
}
if (fltr_name[0] != '\0')
flname = fltr_name;
sfilt.ff_ruleno = ruleno;
/* get filter destination address */
if (!get_ip6addr(&cp, &sfilt.ff_flow6.fi6_dst,
&sfilt.ff_mask6.mask6_dst)) {
LOG(LOG_ERR, 0, "bad destination address");
return (0);
}
/* get filter destination port */
if (!next_word(&cp, w)) {
LOG(LOG_ERR, 0, "missing filter destination port");
return (0);
}
if (!get_port(w, &sfilt.ff_flow6.fi6_dport)) {
LOG(LOG_ERR, 0, "bad filter destination port");
return (0);
}
/* get filter source address */
if (!get_ip6addr(&cp, &sfilt.ff_flow6.fi6_src,
&sfilt.ff_mask6.mask6_src)) {
LOG(LOG_ERR, 0, "bad source address");
return (0);
}
/* get filter source port */
if (!next_word(&cp, w)) {
LOG(LOG_ERR, 0, "missing filter source port");
return (0);
}
if (!get_port(w, &sfilt.ff_flow6.fi6_sport)) {
LOG(LOG_ERR, 0, "bad filter source port");
return (0);
}
/* get filter protocol id */
if (!next_word(&cp, w)) {
LOG(LOG_ERR, 0, "missing filter protocol");
return (0);
}
if (!get_proto(w, &protocol)) {
LOG(LOG_ERR, 0, "bad protocol");
return (0);
}
sfilt.ff_flow6.fi6_proto = protocol;
while (next_word(&cp, w)) {
if (EQUAL(w, "tclass")) {
tclass = 0;
tclassmask = 0xff;
if (next_word(&cp, w)) {
tclass = (u_char)strtol(w, NULL, 0);
if (next_word(&cp, w)) {
if (EQUAL(w, "tclassmask")) {
next_word(&cp, w);
tclassmask =
(u_char)strtol(w, NULL, 0);
}
}
}
sfilt.ff_flow6.fi6_tclass = tclass;
sfilt.ff_mask6.mask6_tclass = tclassmask;
} else if (EQUAL(w, "gpi")) {
if (next_word(&cp, w)) {
sfilt.ff_flow6.fi6_gpi =
(u_int32_t)strtoul(w, NULL, 0);
sfilt.ff_flow6.fi6_gpi =
htonl(sfilt.ff_flow6.fi6_gpi);
}
} else if (EQUAL(w, "flowlabel")) {
if (next_word(&cp, w)) {
sfilt.ff_flow6.fi6_flowlabel =
(u_int32_t)strtoul(w, NULL, 0) & 0x000fffff;
sfilt.ff_flow6.fi6_flowlabel =
htonl(sfilt.ff_flow6.fi6_flowlabel);
}
} else if (EQUAL(w, "dontwarn"))
dontwarn = 1;
}
/*
* Add the filter.
*/
filter_dontwarn = dontwarn; /* XXX */
ret = qcmd_add_filter(ifname, class_name, flname,
(struct flow_filter *)&sfilt);
filter_dontwarn = 0; /* XXX */
if (ret) {
LOG(LOG_ERR, 0,
"can't add filter to class '%s' on interface '%s'",
class_name, ifname);
return (0);
}
return (1);
}
/*
* MPID_Iprobe
*/
void MPID_Iprobe(struct MPIR_COMMUNICATOR *comm,
int tag,
int context_id,
int src_lrank,
int *found,
int *error_code,
MPI_Status *status)
{
MPIR_RHANDLE *unexpected = (MPIR_RHANDLE *) NULL;
*found = GLOBUS_FALSE;
# ifdef VMPI
{
int proto = get_proto(comm, src_lrank);
if (proto == mpi || proto == unknown)
{
void * vmpi_status;
int vmpi_src;
int vmpi_tag;
vmpi_status = STATUS_INFO_GET_VMPI_PTR(*status);
if (src_lrank == MPI_ANY_SOURCE)
{
vmpi_src = VMPI_ANY_SOURCE;
}
else
{
vmpi_src = comm->lrank_to_vlrank[src_lrank];
}
vmpi_tag = (tag == MPI_ANY_TAG ? VMPI_ANY_TAG : tag);
*error_code = vmpi_error_to_mpich_error(
mp_iprobe(vmpi_src,
vmpi_tag,
comm->vmpi_comm,
found,
vmpi_status));
if (*found)
{
status->MPI_SOURCE = comm->vlrank_to_lrank[
mp_status_get_source(vmpi_status)];
status->MPI_TAG = mp_status_get_tag(vmpi_status);
status->MPI_ERROR = *error_code;
STATUS_INFO_SET_COUNT_VMPI(*status);
}
if (*found || *error_code != MPI_SUCCESS)
{
return;
}
} /* endif */
}
# endif
/* try TCP */
/*
* need G2_POLL here so that if MPID_Iprobe called
* by MPID_probe() progress is guaranteed, that is, if
* MPID_Probe is called before TCP data arrives the waiting
* proc (i.e, the one that called MPI_Probe) must be assured
* that once the TCP data is sent that it (a) will be received
* and (b) it will be detected (i.e., progress).
*/
G2_POLL
/* search 'unexpected' queue ... does NOT remove from queue */
MPID_Search_unexpected_queue(src_lrank,
tag,
context_id,
GLOBUS_FALSE, /* do not remove from queue */
&unexpected);
if (unexpected)
{
*found = GLOBUS_TRUE;
status->MPI_SOURCE = unexpected->s.MPI_SOURCE;
status->MPI_TAG = unexpected->s.MPI_TAG;
status->MPI_ERROR = unexpected->s.MPI_ERROR;
/*
* setting status->count and bits in status->private_count
* to indicate that status->count should be interpreted
* (e.g., by MPID_Get_{count,elements} as nbytes in data
* origin format
*/
status->count = unexpected->len;
STATUS_INFO_SET_FORMAT(*status, unexpected->src_format);
STATUS_INFO_SET_COUNT_REMOTE(*status);
} /* endif */
} /* end MPID_Iprobe() */
/* introduce a new uac to transaction; returns its branch id (>=0)
or error (<0); it doesn't send a message yet -- a reply to it
might interfere with the processes of adding multiple branches
*/
int add_uac( struct cell *t, struct sip_msg *request, str *uri, str* next_hop,
struct proxy_l *proxy, int proto )
{
int ret;
short temp_proxy;
union sockaddr_union to;
unsigned short branch;
struct socket_info* send_sock;
char *shbuf;
unsigned int len;
branch=t->nr_of_outgoings;
if (branch==MAX_BRANCHES) {
LOG(L_ERR, "ERROR: add_uac: maximum number of branches exceeded\n");
ret=E_CFG;
goto error;
}
/* check existing buffer -- rewriting should never occur */
if (t->uac[branch].request.buffer) {
LOG(L_CRIT, "ERROR: add_uac: buffer rewrite attempt\n");
ret=ser_error=E_BUG;
goto error;
}
/* check DNS resolution */
if (proxy) {
temp_proxy=0;
proto=get_proto(proto, proxy->proto);
} else {
proxy=uri2proxy( next_hop ? next_hop : uri, proto );
if (proxy==0) {
ret=E_BAD_ADDRESS;
goto error;
}
proto=proxy->proto; /* uri2proxy will fix it for us */
temp_proxy=1;
}
if (proxy->ok==0) {
if (proxy->host.h_addr_list[proxy->addr_idx+1])
proxy->addr_idx++;
else proxy->addr_idx=0;
proxy->ok=1;
}
hostent2su( &to, &proxy->host, proxy->addr_idx,
proxy->port ? proxy->port:SIP_PORT);
send_sock=get_send_socket( request, &to , proto);
if (send_sock==0) {
LOG(L_ERR, "ERROR: add_uac: can't fwd to af %d, proto %d "
" (no corresponding listening socket)\n",
to.s.sa_family, proto );
ret=ser_error=E_NO_SOCKET;
goto error01;
}
/* now message printing starts ... */
shbuf=print_uac_request( t, request, branch, uri,
&len, send_sock, proto );
if (!shbuf) {
ret=ser_error=E_OUT_OF_MEM;
goto error01;
}
/* things went well, move ahead and install new buffer! */
t->uac[branch].request.dst.to=to;
t->uac[branch].request.dst.send_sock=send_sock;
t->uac[branch].request.dst.proto=proto;
t->uac[branch].request.dst.proto_reserved1=0;
t->uac[branch].request.buffer=shbuf;
t->uac[branch].request.buffer_len=len;
t->uac[branch].uri.s=t->uac[branch].request.buffer+
request->first_line.u.request.method.len+1;
t->uac[branch].uri.len=uri->len;
t->nr_of_outgoings++;
/* update stats */
proxy->tx++;
proxy->tx_bytes+=len;
/* done! */
ret=branch;
error01:
if (temp_proxy) {
free_proxy( proxy );
pkg_free( proxy );
}
error:
return ret;
}
static int ppp_rx(struct sk_buff *skb)
{
struct hdlc_header *hdr = (struct hdlc_header*)skb->data;
struct net_device *dev = skb->dev;
struct ppp *ppp = get_ppp(dev);
struct proto *proto;
struct cp_header *cp;
unsigned long flags;
unsigned int len;
u16 pid;
#if DEBUG_CP
int i;
char *ptr;
#endif
spin_lock_irqsave(&ppp->lock, flags);
/* Check HDLC header */
if (skb->len < sizeof(struct hdlc_header))
goto rx_error;
cp = (struct cp_header*)skb_pull(skb, sizeof(struct hdlc_header));
if (hdr->address != HDLC_ADDR_ALLSTATIONS ||
hdr->control != HDLC_CTRL_UI)
goto rx_error;
pid = ntohs(hdr->protocol);
proto = get_proto(dev, pid);
if (!proto) {
if (ppp->protos[IDX_LCP].state == OPENED)
ppp_tx_cp(dev, PID_LCP, LCP_PROTO_REJ,
++ppp->seq, skb->len + 2, &hdr->protocol);
goto rx_error;
}
len = ntohs(cp->len);
if (len < sizeof(struct cp_header) /* no complete CP header? */ ||
skb->len < len /* truncated packet? */)
goto rx_error;
skb_pull(skb, sizeof(struct cp_header));
len -= sizeof(struct cp_header);
/* HDLC and CP headers stripped from skb */
#if DEBUG_CP
if (cp->code < CP_CODES)
sprintf(debug_buffer, "[%s id 0x%X]", code_names[cp->code],
cp->id);
else
sprintf(debug_buffer, "[code %u id 0x%X]", cp->code, cp->id);
ptr = debug_buffer + strlen(debug_buffer);
for (i = 0; i < min_t(unsigned int, len, DEBUG_CP); i++) {
sprintf(ptr, " %02X", skb->data[i]);
ptr += strlen(ptr);
}
printk(KERN_DEBUG "%s: RX %s %s\n", dev->name, proto_name(pid),
debug_buffer);
#endif
/* LCP only */
if (pid == PID_LCP)
switch (cp->code) {
case LCP_PROTO_REJ:
pid = ntohs(*(__be16*)skb->data);
if (pid == PID_LCP || pid == PID_IPCP ||
pid == PID_IPV6CP)
ppp_cp_event(dev, pid, RXJ_BAD, 0, 0,
0, NULL);
goto out;
case LCP_ECHO_REQ: /* send Echo-Reply */
if (len >= 4 && proto->state == OPENED)
ppp_tx_cp(dev, PID_LCP, LCP_ECHO_REPLY,
cp->id, len - 4, skb->data + 4);
goto out;
case LCP_ECHO_REPLY:
if (cp->id == ppp->echo_id)
ppp->last_pong = jiffies;
goto out;
case LCP_DISC_REQ: /* discard */
goto out;
}
/* LCP, IPCP and IPV6CP */
switch (cp->code) {
case CP_CONF_REQ:
ppp_cp_parse_cr(dev, pid, cp->id, len, skb->data);
goto out;
case CP_CONF_ACK:
if (cp->id == proto->cr_id)
ppp_cp_event(dev, pid, RCA, 0, 0, 0, NULL);
goto out;
case CP_CONF_REJ:
case CP_CONF_NAK:
if (cp->id == proto->cr_id)
ppp_cp_event(dev, pid, RCN, 0, 0, 0, NULL);
goto out;
case CP_TERM_REQ:
ppp_cp_event(dev, pid, RTR, 0, cp->id, 0, NULL);
goto out;
case CP_TERM_ACK:
ppp_cp_event(dev, pid, RTA, 0, 0, 0, NULL);
goto out;
case CP_CODE_REJ:
ppp_cp_event(dev, pid, RXJ_BAD, 0, 0, 0, NULL);
goto out;
default:
len += sizeof(struct cp_header);
if (len > dev->mtu)
len = dev->mtu;
ppp_cp_event(dev, pid, RUC, 0, 0, len, cp);
goto out;
}
goto out;
rx_error:
dev->stats.rx_errors++;
out:
spin_unlock_irqrestore(&ppp->lock, flags);
dev_kfree_skb_any(skb);
ppp_tx_flush();
return NET_RX_DROP;
}
/* SCA: RCR+ must supply id, len and data
SCN: RCR- must supply code, id, len and data
STA: RTR must supply id
SCJ: RUC must supply CP packet len and data */
static void ppp_cp_event(struct net_device *dev, u16 pid, u16 event, u8 code,
u8 id, unsigned int len, const void *data)
{
int old_state, action;
struct ppp *ppp = get_ppp(dev);
struct proto *proto = get_proto(dev, pid);
old_state = proto->state;
BUG_ON(old_state >= STATES);
BUG_ON(event >= EVENTS);
#if DEBUG_STATE
printk(KERN_DEBUG "%s: %s ppp_cp_event(%s) %s ...\n", dev->name,
proto_name(pid), event_names[event], state_names[proto->state]);
#endif
action = cp_table[event][old_state];
proto->state = action & STATE_MASK;
if (action & (SCR | STR)) /* set Configure-Req/Terminate-Req timer */
mod_timer(&proto->timer, proto->timeout =
jiffies + ppp->req_timeout * HZ);
if (action & ZRC)
proto->restart_counter = 0;
if (action & IRC)
proto->restart_counter = (proto->state == STOPPING) ?
ppp->term_retries : ppp->cr_retries;
if (action & SCR) /* send Configure-Request */
ppp_tx_cp(dev, pid, CP_CONF_REQ, proto->cr_id = ++ppp->seq,
0, NULL);
if (action & SCA) /* send Configure-Ack */
ppp_tx_cp(dev, pid, CP_CONF_ACK, id, len, data);
if (action & SCN) /* send Configure-Nak/Reject */
ppp_tx_cp(dev, pid, code, id, len, data);
if (action & STR) /* send Terminate-Request */
ppp_tx_cp(dev, pid, CP_TERM_REQ, ++ppp->seq, 0, NULL);
if (action & STA) /* send Terminate-Ack */
ppp_tx_cp(dev, pid, CP_TERM_ACK, id, 0, NULL);
if (action & SCJ) /* send Code-Reject */
ppp_tx_cp(dev, pid, CP_CODE_REJ, ++ppp->seq, len, data);
if (old_state != OPENED && proto->state == OPENED) {
printk(KERN_INFO "%s: %s up\n", dev->name, proto_name(pid));
if (pid == PID_LCP) {
netif_dormant_off(dev);
ppp_cp_event(dev, PID_IPCP, START, 0, 0, 0, NULL);
ppp_cp_event(dev, PID_IPV6CP, START, 0, 0, 0, NULL);
ppp->last_pong = jiffies;
mod_timer(&proto->timer, proto->timeout =
jiffies + ppp->keepalive_interval * HZ);
}
}
if (old_state == OPENED && proto->state != OPENED) {
printk(KERN_INFO "%s: %s down\n", dev->name, proto_name(pid));
if (pid == PID_LCP) {
netif_dormant_on(dev);
ppp_cp_event(dev, PID_IPCP, STOP, 0, 0, 0, NULL);
ppp_cp_event(dev, PID_IPV6CP, STOP, 0, 0, 0, NULL);
}
}
if (old_state != CLOSED && proto->state == CLOSED)
del_timer(&proto->timer);
#if DEBUG_STATE
printk(KERN_DEBUG "%s: %s ppp_cp_event(%s) ... %s\n", dev->name,
proto_name(pid), event_names[event], state_names[proto->state]);
#endif
}
/* WARNING: doesn't work from failure route (deadlock, uses t_reply => tries
* to get the reply lock again */
int t_relay_to( struct sip_msg *p_msg , struct proxy_l *proxy, int proto,
int replicate)
{
int ret;
int new_tran;
int reply_ret;
/* struct hdr_field *hdr; */
struct cell *t;
struct dest_info dst;
unsigned short port;
str host;
short comp;
ret=0;
new_tran = t_newtran( p_msg );
/* parsing error, memory alloc, whatever ... if via is bad
and we are forced to reply there, return with 0 (->break),
pass error status otherwise
MMA: return value E_SCRIPT means that transaction was already started from the script
so continue with that transaction
*/
if (new_tran!=E_SCRIPT) {
if (new_tran<0) {
ret = (ser_error==E_BAD_VIA && reply_to_via) ? 0 : new_tran;
goto done;
}
/* if that was a retransmission, return we are happily done */
if (new_tran==0) {
ret = 1;
goto done;
}
}
/* new transaction */
/* ACKs do not establish a transaction and are fwd-ed statelessly */
if ( p_msg->REQ_METHOD==METHOD_ACK) {
DBG( "SER: forwarding ACK statelessly \n");
if (proxy==0) {
init_dest_info(&dst);
dst.proto=proto;
if (get_uri_send_info(GET_NEXT_HOP(p_msg), &host, &port,
&dst.proto, &comp)!=0){
ret=E_BAD_ADDRESS;
goto done;
}
#ifdef USE_COMP
dst.comp=comp;
#endif
/* dst->send_sock not set, but forward_request will take care
* of it */
ret=forward_request(p_msg, &host, port, &dst);
} else {
init_dest_info(&dst);
dst.proto=get_proto(proto, proxy->proto);
proxy2su(&dst.to, proxy);
/* dst->send_sock not set, but forward_request will take care
* of it */
ret=forward_request( p_msg , 0, 0, &dst) ;
}
goto done;
}
/* if replication flag is set, mark the transaction as local
so that replies will not be relayed */
t=get_t();
if (replicate) t->flags|=T_IS_LOCAL_FLAG;
/* INVITE processing might take long, particularly because of DNS
look-ups -- let upstream know we're working on it */
if (p_msg->REQ_METHOD==METHOD_INVITE )
{
DBG( "SER: new INVITE\n");
if (!t_reply( t, p_msg , 100 ,
"trying -- your call is important to us"))
DBG("SER: ERROR: t_reply (100)\n");
}
/* now go ahead and forward ... */
ret=t_forward_nonack(t, p_msg, proxy, proto);
if (ret<=0) {
DBG( "ERROR:tm:t_relay_to: t_forward_nonack returned error \n");
/* we don't want to pass upstream any reply regarding replicating
* a request; replicated branch must stop at us*/
if (!replicate) {
reply_ret=kill_transaction( t );
if (reply_ret>0) {
/* we have taken care of all -- do nothing in
script */
DBG("ERROR: generation of a stateful reply "
"on error succeeded\n");
/*ret=0; -- we don't want to stop the script */
} else {
DBG("ERROR: generation of a stateful reply "
"on error failed\n");
t_release_transaction(t);
}
}else{
t_release_transaction(t); /* kill it silently */
}
} else {
DBG( "SER: new transaction fwd'ed\n");
}
done:
return ret;
}
int t_relay_to( struct sip_msg *p_msg , struct proxy_l *proxy, int proto,
int replicate)
{
int ret;
int new_tran;
str *uri;
int reply_ret;
/* struct hdr_field *hdr; */
struct cell *t;
ret=0;
new_tran = t_newtran( p_msg );
/* parsing error, memory alloc, whatever ... if via is bad
and we are forced to reply there, return with 0 (->break),
pass error status otherwise
*/
if (new_tran<0) {
ret = (ser_error==E_BAD_VIA && reply_to_via) ? 0 : new_tran;
goto done;
}
/* if that was a retransmission, return we are happily done */
if (new_tran==0) {
ret = 1;
goto done;
}
/* new transaction */
/* ACKs do not establish a transaction and are fwd-ed statelessly */
if ( p_msg->REQ_METHOD==METHOD_ACK) {
DBG("DEBUG:tm:t_relay: forwarding ACK statelessly \n");
if (proxy==0) {
uri = GET_RURI(p_msg);
proxy=uri2proxy(GET_NEXT_HOP(p_msg), proto);
if (proxy==0) {
ret=E_BAD_ADDRESS;
goto done;
}
proto=proxy->proto; /* uri2proxy set it correctly */
ret=forward_request( p_msg , proxy, proto) ;
free_proxy( proxy );
pkg_free( proxy );
} else {
proto=get_proto(proto, proxy->proto);
ret=forward_request( p_msg , proxy, proto ) ;
}
goto done;
}
/* if replication flag is set, mark the transaction as local
so that replies will not be relaied */
t=get_t();
if (replicate) t->flags|=T_IS_LOCAL_FLAG;
/* INVITE processing might take long, particularly because of DNS
look-ups -- let upstream know we're working on it */
if (p_msg->REQ_METHOD==METHOD_INVITE )
{
DBG("DEBUG:tm:t_relay: new INVITE\n");
if (!t_reply( t, p_msg , 100 ,
"trying -- your call is important to us"))
DBG("SER: ERROR: t_reply (100)\n");
}
/* now go ahead and forward ... */
ret=t_forward_nonack(t, p_msg, proxy, proto);
if (ret<=0) {
DBG( "ERROR:tm:t_relay_to: t_forward_nonack returned error \n");
/* we don't want to pass upstream any reply regarding replicating
* a request; replicated branch must stop at us*/
if (!replicate) {
reply_ret=kill_transaction( t );
if (reply_ret>0) {
/* we have taken care of all -- do nothing in
script */
DBG("ERROR: generation of a stateful reply "
"on error succeeded\n");
ret=0;
} else {
DBG("ERROR: generation of a stateful reply "
"on error failed\n");
}
}
} else {
DBG( "SER: new transaction fwd'ed\n");
}
done:
return ret;
}
