pkt.c

这是一个完全开放的

                attr = nad_find_attr(pkt->nad, 1, -1, "action", NULL);

                if(attr >= 0) {
                    if(NAD_AVAL_L(pkt->nad, attr) == 5 && strncmp("start", NAD_AVAL(pkt->nad, attr), 5) >= 0)
                        pkt->type = pkt_SESS;
                    else if(NAD_AVAL_L(pkt->nad, attr) == 3 && strncmp("end", NAD_AVAL(pkt->nad, attr), 3) >= 0)
                        pkt->type = pkt_SESS_END;
                    else if(NAD_AVAL_L(pkt->nad, attr) == 6 && strncmp("create", NAD_AVAL(pkt->nad, attr), 6) >= 0)
                        pkt->type = pkt_SESS_CREATE;
                    else if(NAD_AVAL_L(pkt->nad, attr) == 6 && strncmp("delete", NAD_AVAL(pkt->nad, attr), 6) >= 0)
                        pkt->type = pkt_SESS_DELETE;
                    else if(NAD_AVAL_L(pkt->nad, attr) == 7 && strncmp("started", NAD_AVAL(pkt->nad, attr), 7) >= 0)
                        pkt->type = pkt_SESS | pkt_SESS_FAILED;
                    else if(NAD_AVAL_L(pkt->nad, attr) == 5 && strncmp("ended", NAD_AVAL(pkt->nad, attr), 5) >= 0)
                        pkt->type = pkt_SESS_END | pkt_SESS_FAILED;
                    else if(NAD_AVAL_L(pkt->nad, attr) == 7 && strncmp("created", NAD_AVAL(pkt->nad, attr), 7) >= 0)
                        pkt->type = pkt_SESS_CREATE | pkt_SESS_FAILED;
                    else if(NAD_AVAL_L(pkt->nad, attr) == 7 && strncmp("deleted", NAD_AVAL(pkt->nad, attr), 7) >= 0)
                        pkt->type = pkt_SESS_DELETE | pkt_SESS_FAILED;

                    return pkt;
                } else {
                    log_debug(ZONE, "missing action on session packet");
                    return pkt;
                }
            }

            log_debug(ZONE, "unknown session namespace packet");

            return pkt;
        }

        log_debug(ZONE, "unknown packet");

        return pkt;
    }

    /* advertisements */
    if(NAD_ENAME_L(nad, 0) == 8 && strncmp("presence", NAD_ENAME(nad, 0), 8) == 0) {
        if(nad_find_attr(nad, 0, -1, "type", "unavailable") >= 0)
            pkt->rtype = route_ADV_UN;
        else
            pkt->rtype = route_ADV;

        attr = nad_find_attr(nad, 0, -1, "from", NULL);
        if(attr >= 0)
            pkt->from = jid_new(sm->pc, NAD_AVAL(nad, attr), NAD_AVAL_L(nad, attr));

        return pkt;
    }

    log_debug(ZONE, "invalid component packet");

    free(pkt);
    return NULL;
}

void pkt_free(pkt_t pkt) {
    log_debug(ZONE, "freeing pkt");

    if(pkt->rto != NULL) jid_free(pkt->rto);
    if(pkt->rfrom != NULL) jid_free(pkt->rfrom);
    if(pkt->to != NULL) jid_free(pkt->to);
    if(pkt->from != NULL) jid_free(pkt->from);
    if(pkt->nad != NULL) nad_free(pkt->nad);
    free(pkt);
}

pkt_t pkt_create(sm_t sm, const char *elem, const char *type, const char *to, const char *from) {
    nad_t nad;
    int ns;

    nad = nad_new(sm->router->nad_cache);

    ns = nad_add_namespace(nad, uri_COMPONENT, NULL);
    nad_append_elem(nad, ns, "route", 0);

    nad_add_namespace(nad, uri_SESSION, "sm");

    ns = nad_add_namespace(nad, uri_CLIENT, NULL);
    nad_append_elem(nad, ns, elem, 1);

    if(type != NULL)
        nad_append_attr(nad, -1, "type", type);
    if(to != NULL)
        nad_append_attr(nad, -1, "to", to);
    if(from != NULL)
        nad_append_attr(nad, -1, "from", from);

    return pkt_new(sm, nad);
}

/** convenience - copy the packet id from src to dest */
void pkt_id(pkt_t src, pkt_t dest) {
    int attr;

    attr = nad_find_attr(src->nad, 1, -1, "id", NULL);
    if(attr >= 0)
        nad_set_attr(dest->nad, 1, -1, "id", NAD_AVAL(src->nad, attr), NAD_AVAL_L(src->nad, attr));
    else
        nad_set_attr(dest->nad, 1, -1, "id", NULL, 0);
}

void pkt_router(pkt_t pkt) {
    mod_ret_t ret;
    int ns, scan;

    if(pkt == NULL) return;

    log_debug(ZONE, "delivering pkt to router");

    if(pkt->to == NULL) {
        log_debug(ZONE, "no to address on packet, unable to route");
        pkt_free(pkt);
        return;
    }

    if(pkt->rto != NULL)
        jid_free(pkt->rto);
    pkt->rto = jid_new(pkt->sm->pc, pkt->to->domain, 0);

    if(pkt->rto == NULL) {
        log_debug(ZONE, "invalid to address on packet, unable to route");
        pkt_free(pkt);
        return;
    }

    nad_set_attr(pkt->nad, 0, -1, "to", pkt->rto->domain, 0);

    if(pkt->rfrom != NULL)
        jid_free(pkt->rfrom);
    pkt->rfrom = jid_new(pkt->sm->pc, pkt->sm->id, 0);

    if(pkt->rfrom == NULL) {
        log_debug(ZONE, "invalid from address on packet, unable to route");
        pkt_free(pkt);
        return;
    }

    nad_set_attr(pkt->nad, 0, -1, "from", pkt->rfrom->domain, 0);

    ret = mm_out_router(pkt->sm->mm, pkt);
    switch(ret) {
        case mod_HANDLED:
            return;

        case mod_PASS:
            
            /* remove sm specifics */
            ns = nad_find_namespace(pkt->nad, 1, uri_SESSION, NULL);
            if(ns > 0) {
                nad_set_attr(pkt->nad, 1, ns, "c2s", NULL, 0);
                nad_set_attr(pkt->nad, 1, ns, "sm", NULL, 0);

                /* forget about the internal namespace too */
                if(pkt->nad->elems[1].ns == ns)
                    pkt->nad->elems[1].ns = pkt->nad->nss[ns].next;

                else {
                    for(scan = pkt->nad->elems[1].ns; pkt->nad->nss[scan].next != -1 && pkt->nad->nss[scan].next != ns; scan = pkt->nad->nss[scan].next);

                    /* got it */
                    if(pkt->nad->nss[scan].next != -1)
                        pkt->nad->nss[scan].next = pkt->nad->nss[ns].next;
                }
            }

            sx_nad_write(pkt->sm->router, pkt->nad);

            /* nad already free'd, free the rest */
            pkt->nad = NULL;
            pkt_free(pkt);

            break;

        default:
            pkt_router(pkt_error(pkt, -ret));

            break;
    }
}

void pkt_sess(pkt_t pkt, sess_t sess) {
    mod_ret_t ret;

    if(pkt == NULL) return;

    log_debug(ZONE, "delivering pkt to session %s", jid_full(sess->jid));

    if(pkt->rto != NULL)
        jid_free(pkt->rto);
    pkt->rto = jid_new(pkt->sm->pc, sess->c2s, 0);

    nad_set_attr(pkt->nad, 0, -1, "to", pkt->rto->domain, 0);

    if(pkt->rfrom != NULL)
        jid_free(pkt->rfrom);
    pkt->rfrom = jid_new(pkt->sm->pc, pkt->sm->id, 0);

    nad_set_attr(pkt->nad, 0, -1, "from", pkt->rfrom->domain, 0);

    ret = mm_out_sess(pkt->sm->mm, sess, pkt);
    switch(ret) {
        case mod_HANDLED:
            return;

        case mod_PASS:
            sess_route(sess, pkt);

            break;

        default:
            pkt_router(pkt_error(pkt, -ret));

            break;
    }
}

/** add an x:delay stamp */
void pkt_delay(pkt_t pkt, time_t t, const char *from) {
    char timestamp[18];
    int ns, elem;

    datetime_out(t, dt_LEGACY, timestamp, 18);
    ns = nad_add_namespace(pkt->nad, uri_DELAY, NULL);
    elem = nad_insert_elem(pkt->nad, 1, ns, "x", NULL);
    nad_set_attr(pkt->nad, elem, -1, "stamp", timestamp, 0);
    if(from != NULL)
        nad_set_attr(pkt->nad, elem, -1, "from", from, 0);

    log_debug(ZONE, "added pkt delay stamp %s", timestamp);
}