Пример #1
0
/*
 * parse attributes TCA_ACT_*
 */
int parse_tca_act(char *msg, char *mp, struct rtattr *acts)
{
    struct rtattr *act[__TCA_ACT_MAX];
    char kind[IFNAMSIZ] = "";

    mp = add_log(msg, mp, "order=%d ", acts->rta_type);

    parse_nested_rtattr(act, __TCA_ACT_MAX-1, acts);

    if(act[TCA_ACT_KIND]) {
        strncpy(kind, (char *)RTA_DATA(act[TCA_ACT_KIND]), sizeof(kind));
        mp = add_log(msg, mp, "action=%s ", kind);
    }

    if(act[TCA_ACT_OPTIONS]) {
        if(!strncmp(kind, "police", sizeof(kind))) {
            if(parse_tca_act_options_police(msg, mp, act[TCA_ACT_OPTIONS]))
                return(1);
            return(0);
        } else if(!strncmp(kind, "gact", sizeof(kind))) {
            if(parse_tca_act_options_gact(msg, mp, act[TCA_ACT_OPTIONS]))
                return(1);
            return(0);
        } else if(!strncmp(kind, "pedit", sizeof(kind))) {
            if(parse_tca_act_options_pedit(msg, mp, act[TCA_ACT_OPTIONS]))
                return(1);
            return(0);
        } else if(!strncmp(kind, "mirred", sizeof(kind))) {
            if(parse_tca_act_options_mirred(msg, mp, act[TCA_ACT_OPTIONS]))
                return(1);
            return(0);
#ifdef HAVE_LINUX_TC_ACT_TC_NAT_H
        } else if(!strncmp(kind, "nat", sizeof(kind))) {
            if(parse_tca_act_options_nat(msg, mp, act[TCA_ACT_OPTIONS]))
                return(1);
            return(0);
#endif
#ifdef HAVE_LINUX_TC_ACT_TC_SKBEDIT_H
        } else if(!strncmp(kind, "skbedit", sizeof(kind))) {
            if(parse_tca_act_options_skbedit(msg, mp, act[TCA_ACT_OPTIONS]))
                return(1);
            return(0);
#endif
#ifdef HAVE_LINUX_TC_ACT_TC_CSUM_H
        } else if(!strncmp(kind, "csum", sizeof(kind))) {
            if(parse_tca_act_options_csum(msg, mp, act[TCA_ACT_OPTIONS]))
                return(1);
            return(0);
#endif
        }
    }

    rec_log("%s", msg);

    return(0);
}
Пример #2
0
/*
 * parse rsvp options
 */
int parse_tca_options_rsvp(char *msg, char **mp, struct tcmsg *tcm, struct rtattr *tca)
{
    struct rtattr *rsvp[__TCA_RSVP_MAX];
    char *mp_tmp = *mp;

    parse_nested_rtattr(rsvp, TCA_RSVP_MAX, tca);

    if(rsvp[TCA_RSVP_CLASSID])
        if(parse_tca_classid(msg, mp, rsvp[TCA_RSVP_CLASSID]))
            return(1);

    if(rsvp[TCA_RSVP_DST])
        if(parse_tca_rsvp_dst(msg, mp, tcm, rsvp[TCA_RSVP_DST]))
            return(1);

    if(rsvp[TCA_RSVP_SRC])
        if(parse_tca_rsvp_src(msg, mp, tcm, rsvp[TCA_RSVP_SRC]))
            return(1);

    if(rsvp[TCA_RSVP_PINFO])
        if(parse_tca_rsvp_pinfo(msg, mp, rsvp[TCA_RSVP_PINFO]))
            return(1);

    if(*mp != mp_tmp)
        rec_log("%s", msg);

    /* rollback pointer */
    *mp = mp_tmp;

    /* logging for each attribute below */
    if(rsvp[TCA_RSVP_POLICE])
        if(parse_tca_act_options_police(msg, *mp, rsvp[TCA_RSVP_POLICE]))
            return(1);

    if(rsvp[TCA_RSVP_ACT])
        if(parse_tca_acts(msg, *mp, rsvp[TCA_RSVP_ACT]))
            return(1);

    return(0);
}
Пример #3
0
/*
 * parse flow options
 */
int parse_tca_options_flow(char *msg, char **mp, struct rtattr *tca)
{
    struct rtattr *flow[__TCA_FLOW_MAX];
    char *mp_tmp = *mp;

    parse_nested_rtattr(flow, TCA_FLOW_MAX, tca);

    if(flow[TCA_FLOW_BASECLASS])
        if(parse_tca_classid(msg, mp, flow[TCA_FLOW_BASECLASS]))
            return(1);

    if(flow[TCA_FLOW_KEYS])
        if(parse_tca_flow_keys(msg, mp, flow[TCA_FLOW_KEYS]))
            return(1);

    if(flow[TCA_FLOW_MODE])
        if(parse_tca_flow_mode(msg, mp, flow[TCA_FLOW_MODE]))
            return(1);

    if(flow[TCA_FLOW_MASK])
        if(parse_tca_mask(msg, mp, flow[TCA_FLOW_MASK]))
            return(1);

    if(flow[TCA_FLOW_XOR])
        if(parse_tca_flow_xor(msg, mp, flow[TCA_FLOW_XOR]))
            return(1);

    if(flow[TCA_FLOW_RSHIFT])
        if(parse_tca_flow_rshift(msg, mp, flow[TCA_FLOW_RSHIFT]))
            return(1);

    if(flow[TCA_FLOW_ADDEND])
        if(parse_tca_flow_addend(msg, mp, flow[TCA_FLOW_ADDEND]))
            return(1);

    if(flow[TCA_FLOW_DIVISOR])
        if(parse_tca_flow_divisor(msg, mp, flow[TCA_FLOW_DIVISOR]))
            return(1);

    if(flow[TCA_FLOW_PERTURB])
        if(parse_tca_flow_perturb(msg, mp, flow[TCA_FLOW_PERTURB]))
            return(1);

    if(*mp != mp_tmp)
        rec_log("%s", msg);

    /* rollback pointer */
    *mp = mp_tmp;

    /* logging for each attribute below */
    if(flow[TCA_FLOW_EMATCHES])
        if(parse_tca_ematch(msg, *mp, flow[TCA_FLOW_EMATCHES]))
            return(1);

    if(flow[TCA_FLOW_POLICE])
        if(parse_tca_act_options_police(msg, *mp, flow[TCA_FLOW_POLICE]))
            return(1);

    if(flow[TCA_FLOW_ACT])
        if(parse_tca_acts(msg, *mp, flow[TCA_FLOW_ACT]))
            return(1);

    return(0);
}