static int std_rcv_pado(struct session* ses,
struct pppoe_packet *p_in,
struct pppoe_packet **p_out){
if( verify_packet(ses, p_in) < 0)
return -1;
if(ses->state != PADO_CODE ){
poe_error(ses,"Unexpected packet: %P",p_in);
return 0;
}
if (DEB_DISC2) {
poe_dbglog (ses,"PADO received: %P", p_in);
}
memcpy(&ses->remote, &p_in->addr, sizeof(struct sockaddr_ll));
memcpy( &ses->curr_pkt.addr, &ses->remote , sizeof(struct sockaddr_ll));
ses->curr_pkt.hdr->code = PADR_CODE;
/* The HOST_UNIQ has been verified already... there's no "if" about this */
/* if(ses->filt->htag) */
copy_tag(&ses->curr_pkt,get_tag(p_in->hdr,PTT_HOST_UNIQ));
if (ses->filt->ntag) {
ses->curr_pkt.tags[TAG_AC_NAME]=NULL;
}
// copy_tag(&ses->curr_pkt,get_tag(p_in->hdr,PTT_AC_NAME));
if(ses->filt->stag) {
ses->curr_pkt.tags[TAG_SRV_NAME]=NULL;
}
copy_tag(&ses->curr_pkt,get_tag(p_in->hdr,PTT_SRV_NAME));
copy_tag(&ses->curr_pkt,get_tag(p_in->hdr,PTT_AC_COOKIE));
copy_tag(&ses->curr_pkt,get_tag(p_in->hdr,PTT_RELAY_SID));
ses->state = PADS_CODE;
create_msg(BCM_PPPOE_CLIENT_STATE_PADS);
syslog(LOG_CRIT,"PPP server detected.\n");
ses->retransmits = 0;
send_disc(ses, &ses->curr_pkt);
(*p_out) = &ses->curr_pkt;
if (ses->np)
return 1;
return 0;
}
static int relay_rcv_padi(struct session* ses,
struct pppoe_packet *p_in,
struct pppoe_packet **p_out){
char tag_buf[32];
struct pppoe_con *newpc = NULL;
struct pppoe_tag *tag = (struct pppoe_tag *) tag_buf;
tag->tag_type = PTT_RELAY_SID;
tag->tag_len = htons(ETH_ALEN + sizeof(struct session *));
memcpy(tag->tag_data, p_in->addr.sll_addr, ETH_ALEN);
memcpy(tag->tag_data + ETH_ALEN, &ses, sizeof(struct session *));
if(! p_in->tags[TAG_RELAY_SID] ){
copy_tag(p_in, tag);
}
poe_dbglog(ses, "Recv'd PADI: %P",p_in);
poe_dbglog(ses, "Recv'd packet: %P",p_in);
newpc = get_con( ntohs(tag->tag_len), tag->tag_data );
if(!newpc){
newpc = (struct pppoe_con *) malloc(sizeof(struct pppoe_con));
memset(newpc , 0, sizeof(struct pppoe_con));
newpc->id = pcid++;
newpc->key_len = ntohs(p_in->tags[TAG_RELAY_SID]->tag_len);
memcpy(newpc->key, p_in->tags[TAG_RELAY_SID]->tag_data, newpc->key_len);
memcpy(newpc->client, p_in->addr.sll_addr, ETH_ALEN);
memcpy(newpc->server, MAC_BCAST_ADDR, ETH_ALEN);
store_con(newpc);
}
++newpc->ref_count;
memset(p_in->addr.sll_addr, 0xff, ETH_ALEN);
p_in->addr.sll_ifindex = ses->remote.sll_ifindex;
send_disc(ses, p_in);
return 0;
}
expr compiler_step_visitor::visit_app(expr const & e) {
buffer<expr> args;
expr const & fn = get_app_args(e, args);
expr new_fn = visit(fn);
bool modified = !is_eqp(fn, new_fn);
for (expr & arg : args) {
expr new_arg = visit(arg);
if (!is_eqp(new_arg, arg))
modified = true;
arg = new_arg;
}
if (!modified)
return e;
else
return copy_tag(e, mk_app(new_fn, args));
}
optional<constraints> try_instance(name const & inst) {
environment const & env = m_C->env();
if (auto decl = env.find(inst)) {
name_generator & ngen = m_C->m_ngen;
buffer<level> ls_buffer;
unsigned num_univ_ps = decl->get_num_univ_params();
for (unsigned i = 0; i < num_univ_ps; i++)
ls_buffer.push_back(mk_meta_univ(ngen.next()));
levels ls = to_list(ls_buffer.begin(), ls_buffer.end());
expr inst_cnst = copy_tag(m_meta, mk_constant(inst, ls));
expr inst_type = instantiate_type_univ_params(*decl, ls);
return try_instance(inst_cnst, inst_type);
} else {
return optional<constraints>();
}
}
virtual expr visit_app(expr const & e) override {
buffer<expr> args;
expr const & fn = get_app_args(e, args);
for (expr & arg : args)
arg = visit(arg);
auto fnidx = get_fn_idx(fn);
if (!fnidx) return replace_visitor_with_tc::visit_app(e);
expr new_fn = m_ues.get_fn(*fnidx);
if (fn == new_fn) return replace_visitor_with_tc::visit_app(e);
unsigned arity = m_ues.get_arity_of(*fnidx);
if (args.size() < arity) {
expr new_e = m_ctx.eta_expand(e);
if (!is_lambda(new_e)) throw_ill_formed_eqns();
return visit(new_e);
}
expr new_fn_type = m_ctx.infer(new_fn);
expr sigma_type = binding_domain(new_fn_type);
expr arg = pack(0, arity, args, sigma_type);
expr r = mk_app(new_fn, arg);
return copy_tag(e, mk_app(r, args.size() - arity, args.data() + arity));
}
expr compiler_step_visitor::visit_lambda_let(expr const & e) {
type_context::tmp_locals locals(m_ctx);
expr t = e;
while (true) {
/* Types are ignored in compilation steps. So, we do not invoke visit for d. */
if (is_lambda(t)) {
expr d = instantiate_rev(binding_domain(t), locals.size(), locals.data());
locals.push_local(binding_name(t), d, binding_info(t));
t = binding_body(t);
} else if (is_let(t)) {
expr d = instantiate_rev(let_type(t), locals.size(), locals.data());
expr v = visit(instantiate_rev(let_value(t), locals.size(), locals.data()));
locals.push_let(let_name(t), d, v);
t = let_body(t);
} else {
break;
}
}
t = instantiate_rev(t, locals.size(), locals.data());
t = visit(t);
return copy_tag(e, locals.mk_lambda(t));
}
/* Copy wrappers that don't tag the closure after copying */
STATIC_INLINE GNUC_ATTR_HOT void
copy(StgClosure **p, const StgInfoTable *info,
StgClosure *src, nat size, nat gen_no)
{
copy_tag(p,info,src,size,gen_no,0);
}
expr goal::mk_meta(name const & n, expr const & type) const {
buffer<expr> locals;
expr this_mvar = get_app_args(m_meta, locals);
expr mvar = copy_tag(this_mvar, mk_metavar(n, Pi(locals, type)));
return copy_tag(m_meta, mk_app(mvar, locals));
}
static int std_rcv_pado(struct session* ses,
struct pppoe_packet *p_in,
struct pppoe_packet **p_out){
if( verify_packet(ses, p_in) < 0)
return -1;
if(ses->state != PADO_CODE ){
poe_error(ses,"Unexpected packet: %P",p_in);
return 0;
}
if (DEB_DISC2) {
poe_dbglog (ses,"PADO received: %P", p_in);
}
// brcm: add code to get service name and put it in the /var/fyi/wan/servicename file
if (p_in->tags[0]->tag_type == PTT_SRV_NAME)
{
char sName[255]="";
char path[64]="";
char cmd[320]="";
memset(sName, 0, p_in->tags[0]->tag_len+1);
strncpy(sName, p_in->tags[0]->tag_data, p_in->tags[0]->tag_len);
#ifdef BRCM_CMS_BUILD
extern char servicename[BUFLEN_264]; /* service name from the connection, defined in options.c */
cmsLog_debug("servicename=%s", sName);
strncpy(servicename, sName, sizeof(servicename));
#else
//printf("PPPoE Service Name: %s\n", sName);
sprintf(path, "%s/%s/%s", "/proc/var/fyi/wan", session_path, "servicename");
sprintf(cmd, "echo %s > %s", sName, path);
system(cmd);
#endif
}
memcpy(&ses->remote, &p_in->addr, sizeof(struct sockaddr_ll));
memcpy( &ses->curr_pkt.addr, &ses->remote , sizeof(struct sockaddr_ll));
ses->curr_pkt.hdr->code = PADR_CODE;
/* The HOST_UNIQ has been verified already... there's no "if" about this */
/* if(ses->filt->htag) */
copy_tag(&ses->curr_pkt,get_tag(p_in->hdr,PTT_HOST_UNIQ));
if (ses->filt->ntag) {
ses->curr_pkt.tags[TAG_AC_NAME]=NULL;
}
// copy_tag(&ses->curr_pkt,get_tag(p_in->hdr,PTT_AC_NAME));
#if 1 //brcm
/* Our service name has been verified against the service name tags offered by
* the server in the call to verify_packet(). We can just use it.
*/
copy_tag(&ses->curr_pkt, ses->filt->stag);
#else
if(ses->filt->stag) {
ses->curr_pkt.tags[TAG_SRV_NAME]=NULL;
}
copy_tag(&ses->curr_pkt,get_tag(p_in->hdr,PTT_SRV_NAME));
#endif
copy_tag(&ses->curr_pkt,get_tag(p_in->hdr,PTT_AC_COOKIE));
copy_tag(&ses->curr_pkt,get_tag(p_in->hdr,PTT_RELAY_SID));
ses->state = PADS_CODE;
create_msg(BCM_PPPOE_CLIENT_STATE_PADS, MDMVS_ERROR_NONE);
syslog(LOG_CRIT,"PPP server detected.\n");
ses->retransmits = 0;
send_disc(ses, &ses->curr_pkt);
(*p_out) = &ses->curr_pkt;
if (ses->np)
return 1;
return 0;
}
static int std_rcv_pado(struct session* ses,
struct pppoe_packet *p_in,
struct pppoe_packet **p_out){
struct pppoe_tag *ac_name, *srv_name;
char ac[1024], srv[1024];
if(ses->state != PADO_CODE ){
poe_error(ses,"Unexpected packet: %P",p_in);
return 0;
}
if( verify_packet(ses, p_in) < 0)
return 0;
if (DEB_DISC2)
poe_dbglog (ses,"PADO received: %P", p_in);
memcpy(&ses->remote, &p_in->addr, sizeof(struct sockaddr_ll));
memcpy(&ses->curr_pkt.addr, &ses->remote , sizeof(struct sockaddr_ll));
ses->curr_pkt.hdr->code = PADR_CODE;
/* The HOST_UNIQ has been verified already... there's no "if" about this */
/* if(ses->filt->htag) */
copy_tag(&ses->curr_pkt,get_tag(p_in->hdr,PTT_HOST_UNIQ));
if (ses->filt->ntag) {
ses->curr_pkt.tags[TAG_AC_NAME]=NULL;
}
ac_name = get_tag(p_in->hdr,PTT_AC_NAME);
srv_name = get_tag(p_in->hdr,PTT_SRV_NAME);
memset(ac, 0, sizeof(ac));
memset(srv, 0, sizeof(srv));
strncpy(ac, ac_name->tag_data, ntohs(ac_name->tag_len));
strncpy(srv, srv_name->tag_data, ntohs(srv_name->tag_len));
script_setenv("AC_NAME", ac, 1);
script_setenv("SRV_NAME", srv, 1);
if(ses->filt->stag) {
ses->curr_pkt.tags[TAG_SRV_NAME]=NULL;
}
copy_tag(&ses->curr_pkt,get_tag(p_in->hdr,PTT_SRV_NAME));
copy_tag(&ses->curr_pkt,get_tag(p_in->hdr,PTT_AC_COOKIE));
copy_tag(&ses->curr_pkt,get_tag(p_in->hdr,PTT_RELAY_SID));
ses->state = PADS_CODE;
ses->retransmits = 0;
send_disc(ses, &ses->curr_pkt);
(*p_out) = &ses->curr_pkt;
if (DEB_DISC)
poe_dbglog (ses,"Sent PADR: %P", *p_out);
if (ses->np)
return 1;
return 0;
}
/** \brief Given a term <tt>a : a_type</tt>, and a metavariable \c m, creates a constraint
that considers coercions from a_type to the type assigned to \c m. */
constraint mk_coercion_cnstr(type_checker & from_tc, type_checker & to_tc, coercion_info_manager & infom,
expr const & m, expr const & a, expr const & a_type,
justification const & j, unsigned delay_factor, bool lift_coe) {
auto choice_fn = [=, &from_tc, &to_tc, &infom](expr const & meta, expr const & d_type, substitution const & s) {
expr new_a_type;
justification new_a_type_jst;
if (is_meta(a_type)) {
auto p = substitution(s).instantiate_metavars(a_type);
new_a_type = p.first;
new_a_type_jst = p.second;
} else {
new_a_type = a_type;
}
if (is_meta(new_a_type)) {
if (delay_factor < to_delay_factor(cnstr_group::DelayedChoice)) {
// postpone...
return lazy_list<constraints>(constraints(mk_coercion_cnstr(from_tc, to_tc, infom, m, a, a_type, justification(),
delay_factor+1, lift_coe)));
} else {
// giveup...
return lazy_list<constraints>(constraints(mk_eq_cnstr(meta, a, justification())));
}
}
constraint_seq cs;
new_a_type = from_tc.whnf(new_a_type, cs);
if ((lift_coe && is_pi_meta(d_type)) || (!lift_coe && is_meta(d_type))) {
// case-split
buffer<expr> locals;
expr it_from = new_a_type;
expr it_to = d_type;
while (is_pi(it_from) && is_pi(it_to)) {
expr dom_from = binding_domain(it_from);
expr dom_to = binding_domain(it_to);
if (!from_tc.is_def_eq(dom_from, dom_to, justification(), cs))
return lazy_list<constraints>();
expr local = mk_local(mk_fresh_name(), binding_name(it_from), dom_from, binder_info());
locals.push_back(local);
it_from = instantiate(binding_body(it_from), local);
it_to = instantiate(binding_body(it_to), local);
}
buffer<expr> alts;
get_coercions_from(from_tc.env(), it_from, alts);
expr fn_a;
if (!locals.empty())
fn_a = mk_local(mk_fresh_name(), "f", new_a_type, binder_info());
buffer<constraints> choices;
buffer<expr> coes;
// first alternative: no coercion
constraint_seq cs1 = cs + mk_eq_cnstr(meta, a, justification());
choices.push_back(cs1.to_list());
unsigned i = alts.size();
while (i > 0) {
--i;
expr coe = alts[i];
if (!locals.empty())
coe = Fun(fn_a, Fun(locals, mk_app(coe, mk_app(fn_a, locals))));
expr new_a = copy_tag(a, mk_app(coe, a));
coes.push_back(coe);
constraint_seq csi = cs + mk_eq_cnstr(meta, new_a, new_a_type_jst);
choices.push_back(csi.to_list());
}
return choose(std::make_shared<coercion_elaborator>(infom, meta,
to_list(choices.begin(), choices.end()),
to_list(coes.begin(), coes.end())));
} else {
list<expr> coes = get_coercions_from_to(from_tc, to_tc, new_a_type, d_type, cs, lift_coe);
if (is_nil(coes)) {
expr new_a = a;
infom.erase_coercion_info(a);
cs += mk_eq_cnstr(meta, new_a, new_a_type_jst);
return lazy_list<constraints>(cs.to_list());
} else if (is_nil(tail(coes))) {
expr new_a = copy_tag(a, mk_app(head(coes), a));
infom.save_coercion_info(a, new_a);
cs += mk_eq_cnstr(meta, new_a, new_a_type_jst);
return lazy_list<constraints>(cs.to_list());
} else {
list<constraints> choices = map2<constraints>(coes, [&](expr const & coe) {
expr new_a = copy_tag(a, mk_app(coe, a));
constraint c = mk_eq_cnstr(meta, new_a, new_a_type_jst);
return (cs + c).to_list();
});
return choose(std::make_shared<coercion_elaborator>(infom, meta, choices, coes, false));
}
}
};
return mk_choice_cnstr(m, choice_fn, delay_factor, true, j);
}
void HeadFoot::copy_foot(const char* foot, const char* def)
{
copy_tag(&m_foot, foot, def);
m_flen = (int)strlen( m_foot );
}
void HeadFoot::copy_head(const char* head, const char* def)
{
copy_tag(&m_head, head, def);
m_hlen = (int)strlen(m_head);
}