int
mkInterestCompute(char **namecomp, char *computation, int computationlen, char *out)
{
#ifndef USE_UTIL
DEBUGMSG(TRACE, "mkInterestCompute()\n");
#endif
int len = 0, k, i;
unsigned char *cp;
len += mkHeader(out, CCN_DTAG_INTEREST, CCN_TT_DTAG); // interest
len += mkHeader(out+len, CCN_DTAG_NAME, CCN_TT_DTAG); // name
while (*namecomp) {
len += mkHeader(out+len, CCN_DTAG_COMPONENT, CCN_TT_DTAG); // comp
cp = (unsigned char*) strdup(*namecomp);
k = k = strlen(*namecomp);
len += mkHeader(out+len, k, CCN_TT_BLOB);
memcpy(out+len, cp, k);
len += k;
out[len++] = 0; // end-of-component
free(cp);
namecomp++;
}
len += mkBlob(out+len, CCN_DTAG_COMPONENT, CCN_TT_DTAG, computation, computationlen);
len += mkStrBlob(out+len, CCN_DTAG_COMPONENT, CCN_TT_DTAG, "NFN");
out[len++] = 0; // end-of-name
out[len++] = 0; // end-of-interest
return len;
}
int
mkContent(char **namecomp,
unsigned char *publisher, int plen,
unsigned char *body, int blen,
unsigned char *out)
{
int len = 0, k;
len = mkHeader(out, CCN_DTAG_CONTENTOBJ, CCN_TT_DTAG); // interest
// add signature
#ifdef USE_SIGNATURES
if(private_key_path)
len += add_signature(out+len, private_key_path, body, blen);
#endif
len += mkHeader(out+len, CCN_DTAG_NAME, CCN_TT_DTAG); // name
while (*namecomp) {
len += mkHeader(out+len, CCN_DTAG_COMPONENT, CCN_TT_DTAG); // comp
k = unescape_component((unsigned char*) *namecomp);
len += mkHeader(out+len, k, CCN_TT_BLOB);
memcpy(out+len, *namecomp++, k);
len += k;
out[len++] = 0; // end-of-component
}
out[len++] = 0; // end-of-name
if (publisher) {
struct timeval t;
unsigned char tstamp[6];
uint32_t *sec;
uint16_t *secfrac;
gettimeofday(&t, NULL);
sec = (uint32_t*)(tstamp + 0); // big endian
*sec = htonl(t.tv_sec);
secfrac = (uint16_t*)(tstamp + 4);
*secfrac = htons(4048L * t.tv_usec / 1000000);
len += mkHeader(out+len, CCN_DTAG_TIMESTAMP, CCN_TT_DTAG);
len += mkHeader(out+len, sizeof(tstamp), CCN_TT_BLOB);
memcpy(out+len, tstamp, sizeof(tstamp));
len += sizeof(tstamp);
out[len++] = 0; // end-of-timestamp
len += mkHeader(out+len, CCN_DTAG_SIGNEDINFO, CCN_TT_DTAG);
len += mkHeader(out+len, CCN_DTAG_PUBPUBKDIGEST, CCN_TT_DTAG);
len += mkHeader(out+len, plen, CCN_TT_BLOB);
memcpy(out+len, publisher, plen);
len += plen;
out[len++] = 0; // end-of-publisher
out[len++] = 0; // end-of-signedinfo
}
len += mkHeader(out+len, CCN_DTAG_CONTENT, CCN_TT_DTAG);
len += mkHeader(out+len, blen, CCN_TT_BLOB);
memcpy(out + len, body, blen);
len += blen;
out[len++] = 0; // end-of-content
out[len++] = 0; // end-of-contentobj
return len;
}
int ccnl_frag_getfragcount(struct ccnl_frag_s *e, int origlen, int *totallen)
{
int cnt = 0, len = 0;
unsigned char dummy[256];
int hdrlen, blobtaglen, datalen;
int offs = 0;
if (!e) {
cnt = 1;
}
else if (e && e->protocol == CCNL_FRAG_SEQUENCED2012) {
while (offs < origlen) { /* we could do better than to simulate this: */
hdrlen = mkHeader(dummy, CCNL_DTAG_FRAGMENT2012, CCN_TT_DTAG);
hdrlen += mkBinaryInt(dummy, CCNL_DTAG_FRAG_FLAGS, CCN_TT_DTAG, 0,
e->flagwidth);
hdrlen += mkBinaryInt(dummy, CCNL_DTAG_FRAG_SEQNR, CCN_TT_DTAG, 0,
e->sendseqwidth);
hdrlen += mkBinaryInt(dummy, CCNL_DTAG_FRAG_OLOSS, CCN_TT_DTAG, 0,
e->losscountwidth);
hdrlen += mkBinaryInt(dummy, CCNL_DTAG_FRAG_YSEQN, CCN_TT_DTAG, 0,
e->recvseqwidth);
hdrlen += mkHeader(dummy, CCN_DTAG_CONTENT, CCN_TT_DTAG);
blobtaglen = mkHeader(dummy, e->mtu - hdrlen - 1, CCN_TT_BLOB);
datalen = e->mtu - hdrlen - blobtaglen - 1;
if (datalen > (origlen - offs)) {
datalen = origlen - offs;
}
hdrlen += mkHeader(dummy, datalen, CCN_TT_BLOB);
len += hdrlen + datalen + 1;
offs += datalen;
cnt++;
}
}
else if (e && e->protocol == CCNL_FRAG_CCNx2013) {
while (offs < origlen) { /* we could do better than to simulate this: */
hdrlen = mkHeader(dummy, CCNL_DTAG_FRAGMENT, CCN_TT_DTAG);
hdrlen += mkHeader(dummy, CCNL_DTAG_FRAG_TYPE, CCN_TT_DTAG);
hdrlen += 4; /* three BLOB bytes plus end-of-entry */
hdrlen += mkBinaryInt(dummy, CCNL_DTAG_FRAG_SEQNR, CCN_TT_DTAG, 0,
e->sendseqwidth);
hdrlen += mkBinaryInt(dummy, CCNL_DTAG_FRAG_FLAGS, CCN_TT_DTAG, 0,
e->flagwidth);
hdrlen += mkBinaryInt(dummy, CCNL_DTAG_FRAG_OLOSS, CCN_TT_DTAG, 0,
e->losscountwidth);
hdrlen += mkBinaryInt(dummy, CCNL_DTAG_FRAG_YSEQN, CCN_TT_DTAG, 0,
e->recvseqwidth);
hdrlen += mkHeader(dummy, CCN_DTAG_CONTENT, CCN_TT_DTAG);
blobtaglen = mkHeader(dummy, e->mtu - hdrlen - 1, CCN_TT_BLOB);
datalen = e->mtu - hdrlen - blobtaglen - 1;
if (datalen > (origlen - offs)) {
datalen = origlen - offs;
}
hdrlen += mkHeader(dummy, datalen, CCN_TT_BLOB);
len += hdrlen + datalen + 1;
offs += datalen;
cnt++;
}
}
if (totallen) {
*totallen = len;
}
return cnt;
}
struct ccnl_buf_s *
ccnl_frag_getnextCCNx2013(struct ccnl_frag_s *fr, int *ifndx, sockunion *su)
{
struct ccnl_buf_s *buf = 0;
unsigned char header[256];
int hdrlen, blobtaglen, flagoffs;
unsigned int datalen;
/* switch among encodings of fragments here (ccnb, TLV, etc) */
hdrlen = mkHeader(header, CCNL_DTAG_FRAGMENT, CCN_TT_DTAG); /* fragment */
hdrlen += mkHeader(header + hdrlen, CCNL_DTAG_FRAG_TYPE, CCN_TT_DTAG);
hdrlen += mkHeader(header + hdrlen, 3, CCN_TT_BLOB);
memcpy(header + hdrlen, CCNL_FRAG_TYPE_CCNx2013_VAL, 3); /* "FHBH" */
header[hdrlen + 3] = '\0';
hdrlen += 4;
hdrlen += mkBinaryInt(header + hdrlen, CCNL_DTAG_FRAG_SEQNR, CCN_TT_DTAG,
fr->sendseq, fr->sendseqwidth);
hdrlen += mkBinaryInt(header + hdrlen, CCNL_DTAG_FRAG_FLAGS, CCN_TT_DTAG, 0,
fr->flagwidth);
flagoffs = hdrlen - 2; /* most significant byte of flag element */
/* other optional fields would go here */
hdrlen += mkHeader(header + hdrlen, CCN_DTAG_CONTENT, CCN_TT_DTAG);
blobtaglen = mkHeader(header + hdrlen, fr->mtu - hdrlen - 2, CCN_TT_BLOB);
datalen = fr->mtu - hdrlen - blobtaglen - 2;
if (datalen > (fr->bigpkt->datalen - fr->sendoffs)) {
datalen = fr->bigpkt->datalen - fr->sendoffs;
}
hdrlen += mkHeader(header + hdrlen, datalen, CCN_TT_BLOB);
buf = ccnl_buf_new(NULL, hdrlen + datalen + 2);
if (!buf) {
return NULL;
}
memcpy(buf->data, header, hdrlen);
memcpy(buf->data + hdrlen, fr->bigpkt->data + fr->sendoffs, datalen);
buf->data[hdrlen + datalen] = '\0'; /* end of content field */
buf->data[hdrlen + datalen + 1] = '\0'; /* end of fragment */
/* patch flag field: */
if (datalen >= fr->bigpkt->datalen) { /* single */
buf->data[flagoffs] = CCNL_DTAG_FRAG_FLAG_SINGLE;
ccnl_free(fr->bigpkt);
fr->bigpkt = NULL;
}
else if (fr->sendoffs == 0) { /* start */
buf->data[flagoffs] = CCNL_DTAG_FRAG_FLAG_FIRST;
}
else if (datalen >= (fr->bigpkt->datalen - fr->sendoffs)) { /* end */
buf->data[flagoffs] = CCNL_DTAG_FRAG_FLAG_LAST;
ccnl_free(fr->bigpkt);
fr->bigpkt = NULL;
}
else {
buf->data[flagoffs] = CCNL_DTAG_FRAG_FLAG_MID;
}
fr->sendoffs += datalen;
fr->sendseq++;
if (ifndx) {
*ifndx = fr->ifndx;
}
if (su) {
memcpy(su, &fr->dest, sizeof(*su));
}
return buf;
}
struct ccnl_buf_s *
ccnl_frag_getnextSEQD2012(struct ccnl_frag_s *e, int *ifndx, sockunion *su)
{
struct ccnl_buf_s *buf = 0;
unsigned char header[256];
int hdrlen = 0, blobtaglen, flagoffs;
unsigned int datalen;
DEBUGMSG(16, "ccnl_frag_getnextSEQD2012 e=%p, mtu=%d\n", (void *) e, e->mtu);
DEBUGMSG(17, " %d bytes to fragment, offset=%d\n", e->bigpkt->datalen,
e->sendoffs);
hdrlen = mkHeader(header, CCNL_DTAG_FRAGMENT2012, CCN_TT_DTAG);
hdrlen += mkBinaryInt(header + hdrlen, CCNL_DTAG_FRAG_FLAGS,
CCN_TT_DTAG, 0, e->flagwidth);
flagoffs = hdrlen - 2;
hdrlen += mkBinaryInt(header + hdrlen, CCNL_DTAG_FRAG_YSEQN,
CCN_TT_DTAG, e->recvseq, e->recvseqwidth);
hdrlen += mkBinaryInt(header + hdrlen, CCNL_DTAG_FRAG_OLOSS, CCN_TT_DTAG,
e->losscount, e->losscountwidth);
hdrlen += mkBinaryInt(header + hdrlen, CCNL_DTAG_FRAG_SEQNR,
CCN_TT_DTAG, e->sendseq, e->sendseqwidth);
hdrlen += mkHeader(header + hdrlen, CCN_DTAG_CONTENT, CCN_TT_DTAG);
blobtaglen = mkHeader(header + hdrlen, e->mtu - hdrlen - 2, CCN_TT_BLOB);
datalen = e->mtu - hdrlen - blobtaglen - 2;
if (datalen > (e->bigpkt->datalen - e->sendoffs)) {
datalen = e->bigpkt->datalen - e->sendoffs;
}
hdrlen += mkHeader(header + hdrlen, datalen, CCN_TT_BLOB);
buf = ccnl_buf_new(NULL, hdrlen + datalen + 2);
if (!buf) {
return NULL;
}
memcpy(buf->data, header, hdrlen);
memcpy(buf->data + hdrlen, e->bigpkt->data + e->sendoffs, datalen);
buf->data[hdrlen + datalen] = '\0'; /* end of content/any field */
buf->data[hdrlen + datalen + 1] = '\0'; /* end of fragment/pdu */
if (datalen >= e->bigpkt->datalen) { /* fits in a single fragment */
buf->data[flagoffs + e->flagwidth - 1] =
CCNL_DTAG_FRAG_FLAG_FIRST | CCNL_DTAG_FRAG_FLAG_LAST;
ccnl_free(e->bigpkt);
e->bigpkt = NULL;
}
else if (e->sendoffs == 0) { /* this is the start fragment */
buf->data[flagoffs + e->flagwidth - 1] = CCNL_DTAG_FRAG_FLAG_FIRST;
}
else if (datalen >= (e->bigpkt->datalen - e->sendoffs)) { /* the end */
buf->data[flagoffs + e->flagwidth - 1] = CCNL_DTAG_FRAG_FLAG_LAST;
ccnl_free(e->bigpkt);
e->bigpkt = NULL;
}
else
/* in the middle */
{
buf->data[flagoffs + e->flagwidth - 1] = 0x00;
}
e->sendoffs += datalen;
e->sendseq++;
DEBUGMSG(17, " e->offset now %d\n", e->sendoffs);
if (ifndx) {
*ifndx = e->ifndx;
}
if (su) {
memcpy(su, &e->dest, sizeof(*su));
}
return buf;
}
