CtlPktSav.cpp

#include "CtlPkt.h"

namespace forest {


CtlPkt::CtlPkt() { payload = 0; reset(); }

CtlPkt::CtlPkt(CpTypeIndex cpt, CpRrType rrt, uint64_t seq) 
                                : cpType(cpt), rrType(rrt), seqNum(seq) {
                payload = 0; reset();
}

CtlPkt::~CtlPkt() { } 

void CtlPkt::reset() {
                for (int i = CPA_START; i < CPA_END; i++) aSet[i] = false;
}
void CtlPkt::reset(CpTypeIndex cpt, CpRrType rrt, uint64_t seq) {
                cpType = cpt; rrType = rrt; seqNum = seq;
                payload = 0; reset();
}

int CtlPkt::pack(uint32_t* pl) {
                payload = pl;
                if (!CpType::validIndex(cpType))
                                return 0;
                if (rrType != REQUEST && rrType != POS_REPLY && rrType != NEG_REPLY)
                                return 0;
                pp = 0;
                payload[pp++] = htonl(CpType::getCode(cpType));
                payload[pp++] = htonl(rrType);
                payload[pp++] = htonl((uint32_t) (seqNum >> 32));
                payload[pp++] = htonl((uint32_t) (seqNum & 0xffffffff));

                if (rrType == REQUEST) {
                                // pack all request attributes and confirm that
                                // required attributes are present
                                for (int i = CPA_START + 1; i < CPA_END; i++) {
                                                CpAttrIndex ii = CpAttrIndex(i);
                                                if (CpType::isReqAttr(cpType, ii)) {
                                                                if (isSet(ii)) packAttr(ii);
                                                                else if (CpType::isReqReqAttr(cpType,ii))
                                                                                return 0;
                                                }
                                }
                } else if (rrType == POS_REPLY) {
                                for (int i = CPA_START + 1; i < CPA_END; i++) {
                                                CpAttrIndex ii = CpAttrIndex(i);
                                                if (CpType::isRepAttr(cpType, ii)) {
                                                                if (isSet(ii)) packAttr(ii);
                                                                else { 
                                                                                return 0;
                                                                }
                                                }
                                }
                } else {
                                int j = Util::strnlen(errMsg,MAX_MSG_LEN);
                                if (j == MAX_MSG_LEN) errMsg[MAX_MSG_LEN] = 0;
                                strncpy((char*) &payload[pp], errMsg, j+1);
                                return 4*pp + j+1;
                }

                return 4*pp;
}

bool CtlPkt::unpack(uint32_t* pl, int pleng) {
                payload = pl;
                pleng /= 4; // to get length in 32 bit words
                if (pleng < 4) return false; // too short for control packet

                pp = 0;
                cpType = CpType::getIndexByCode(ntohl(payload[pp++]));
                rrType = (CpRrType) ntohl(payload[pp++]);
                seqNum = ntohl(payload[pp++]); seqNum <<= 32;
                seqNum |= ntohl(payload[pp++]);

                if (!CpType::validIndex(cpType)) return false;
                if (rrType != REQUEST && rrType != POS_REPLY && rrType != NEG_REPLY)
                                return false;
                
                if (rrType == NEG_REPLY) {
                                strncpy(errMsg,(char*) &payload[pp], MAX_MSG_LEN);
                                errMsg[MAX_MSG_LEN] = 0;
                                return true;
                }

                // unpack all attribute/value pairs
                while (pp < pleng-1) { if (unpackAttr() == 0) return false; }

                if (rrType == REQUEST) {
                                // confirm that required attributes are present
                                for (int i = CPA_START + 1; i < CPA_END; i++) {
                                                CpAttrIndex ii = CpAttrIndex(i);
                                                if (CpType::isReqReqAttr(cpType, ii) && !isSet(ii)) {
                                                                return false;
                                                }
                                }
                } else {
                                // confirm that all reply attributes are present
                                for (int i = CPA_START + 1; i < CPA_END; i++) {
                                                CpAttrIndex ii = CpAttrIndex(i);
                                                if (CpType::isRepAttr(cpType, ii) && !isSet(ii)) {
                                                                return false;
                                                }
                                }
                }

                return true;
}

string& CtlPkt::avPair2string(CpAttrIndex ii, string& s) {
                stringstream ss;
                ss << CpAttr::getName(ii) << "=";
                if (!isSet(ii)) {
                                ss << "(missing)"; s = ss.str(); return s;
                }
                int32_t val = getAttr(ii);
                if (ii == COMTREE_OWNER || ii == LEAF_ADR ||
                    ii == PEER_ADR || ii == PEER_DEST ||
                    ii == RTR_ADR || ii == CLIENT_ADR ||
                    ii == FIRST_LEAF_ADR || ii == LAST_LEAF_ADR ||
                    ii == DEST_ADR) {
                                ss << Forest::fAdr2string((fAdr_t) val,s);
                } else if (ii == LOCAL_IP || ii == PEER_IP ||
                                   ii == CLIENT_IP || ii == RTR_IP) {
                                ss << Np4d::ip2string(val,s);
                } else if (ii == PEER_TYPE) {
                                ss << Forest::nodeType2string((ntyp_t) val,s);
                } else {
                                ss << val;
                }
                s = ss.str();
                return s;
}

string& CtlPkt::toString(string& s) {
                stringstream ss;
                bool reqPkt = (rrType == REQUEST);

                ss << CpType::getName(cpType);
                if (reqPkt) ss << " (request,";
                else if (rrType == POS_REPLY) ss << " (pos reply,";
                else ss << " (neg reply,";
                ss << seqNum << "):";

                if (rrType == REQUEST) {
                                for (int i = CPA_START+1; i < CPA_END; i++) {
                                                CpAttrIndex ii = CpAttrIndex(i);
                                                if (!CpType::isReqAttr(cpType,ii)) continue;
                                                if (!CpType::isReqReqAttr(cpType,ii) && !isSet(ii))
                                                                continue;
                                                ss << " " << avPair2string(ii,s);
                                }
                } else if (rrType == POS_REPLY) {
                                for (int i = CPA_START+1; i < CPA_END; i++) {
                                                CpAttrIndex ii = CpAttrIndex(i);
                                                if (!CpType::isRepAttr(cpType,ii)) continue;
                                                ss << " " << avPair2string(ii,s);
                                }
                } else {
                                ss << " errMsg=" << errMsg;
                }
                ss << endl;
                s = ss.str();
                return s;
}

} // ends namespace