int add_signature(unsigned char *out, char *private_key_path, unsigned char *file, unsigned int fsize) { int len; unsigned char sig[2048]; unsigned int sig_len; len = ccnl_ccnb_mkHeader(out, CCN_DTAG_SIGNATURE, CCN_TT_DTAG); len += ccnl_ccnb_mkStrBlob(out + len, CCN_DTAG_NAME, CCN_TT_DTAG, "SHA256"); len += ccnl_ccnb_mkStrBlob(out + len, CCN_DTAG_WITNESS, CCN_TT_DTAG, ""); if(!sign(private_key_path, (unsigned char*)file, fsize, (unsigned char*)sig, &sig_len)) return 0; //printf("SIGLEN: %d\n",sig_len); sig[sig_len]=0; //add signaturebits bits... len += ccnl_ccnb_mkHeader(out + len, CCN_DTAG_SIGNATUREBITS, CCN_TT_DTAG); len += ccnl_ccnb_addBlob(out + len, (char*)sig, sig_len); out[len++] = 0; // end signaturebits out[len++] = 0; // end signature /*char *publickey = "/home/blacksheeep/.ssh/publickey.pem"; int verified = verify(publickey, file, fsize, sig, sig_len); printf("Verified: %d\n", verified);*/ return len; }
int mkEchoserverRequest(unsigned char *out, char *path, int suite, char *private_key_path) { int len = 0, len1 = 0, len2 = 0, len3 = 0; unsigned char out1[CCNL_MAX_PACKET_SIZE]; unsigned char contentobj[2000]; unsigned char fwdentry[2000]; char suite_s[1]; char *cp; DEBUGMSG(DEBUG, "mkEchoserverRequest uri=%s suite=%d\n", path, suite); len = ccnl_ccnb_mkHeader(out, CCN_DTAG_INTEREST, CCN_TT_DTAG); // interest len += ccnl_ccnb_mkHeader(out+len, CCN_DTAG_NAME, CCN_TT_DTAG); // name len1 += ccnl_ccnb_mkStrBlob(out1+len1, CCN_DTAG_COMPONENT, CCN_TT_DTAG, "ccnx"); len1 += ccnl_ccnb_mkStrBlob(out1+len1, CCN_DTAG_COMPONENT, CCN_TT_DTAG, ""); len1 += ccnl_ccnb_mkStrBlob(out1+len1, CCN_DTAG_COMPONENT, CCN_TT_DTAG, "echoserver"); // prepare FWDENTRY len3 = ccnl_ccnb_mkHeader(fwdentry, CCN_DTAG_FWDINGENTRY, CCN_TT_DTAG); len3 += ccnl_ccnb_mkStrBlob(fwdentry+len3, CCN_DTAG_ACTION, CCN_TT_DTAG, "echoserver"); len3 += ccnl_ccnb_mkHeader(fwdentry+len3, CCN_DTAG_NAME, CCN_TT_DTAG); // prefix cp = strtok(path, "/"); while (cp) { unsigned short cmplen = strlen(cp); #ifdef USE_SUITE_CCNTLV if (suite == CCNL_SUITE_CCNTLV) { char* oldcp = cp; cp = malloc( (cmplen + 4) * (sizeof(char)) ); cp[0] = CCNX_TLV_N_NameSegment >> 8; cp[1] = CCNX_TLV_N_NameSegment; cp[2] = cmplen >> 8; cp[3] = cmplen; memcpy(cp + 4, oldcp, cmplen); cmplen += 4; } #endif #ifdef USE_SUITE_CISTLV if (suite == CCNL_SUITE_CISTLV) { char* oldcp = cp; cp = malloc( (cmplen + 4) * (sizeof(char)) ); cp[0] = CISCO_TLV_NameComponent >> 8; cp[1] = CISCO_TLV_NameComponent; cp[2] = cmplen >> 8; cp[3] = cmplen; memcpy(cp + 4, oldcp, cmplen); cmplen += 4; }
int ccnl_ccnb_mkInterest(struct ccnl_prefix_s *name, char *minSuffix, const char *maxSuffix, unsigned char *digest, int dlen, unsigned char *publisher, int plen, char *scope, uint32_t *nonce, unsigned char *out) { int len, i, k; len = ccnl_ccnb_mkHeader(out, CCN_DTAG_INTEREST, CCN_TT_DTAG); // interest len += ccnl_ccnb_mkHeader(out+len, CCN_DTAG_NAME, CCN_TT_DTAG); // name for (i = 0; i < name->compcnt; i++) { len += ccnl_ccnb_mkHeader(out+len, CCN_DTAG_COMPONENT, CCN_TT_DTAG); // comp k = name->complen[i]; len += ccnl_ccnb_mkHeader(out+len, k, CCN_TT_BLOB); memcpy(out+len, name->comp[i], k); len += k; out[len++] = 0; // end-of-component } if (digest) { len += ccnl_ccnb_mkField(out + len, CCN_DTAG_COMPONENT, CCN_TT_BLOB, digest, dlen); if (!maxSuffix) maxSuffix = "0"; } out[len++] = 0; // end-of-name if (minSuffix) len += ccnl_ccnb_mkField(out + len, CCN_DTAG_MINSUFFCOMP, CCN_TT_UDATA, (unsigned char*) minSuffix, strlen(minSuffix)); if (maxSuffix) len += ccnl_ccnb_mkField(out + len, CCN_DTAG_MAXSUFFCOMP, CCN_TT_UDATA, (unsigned char*) maxSuffix, strlen(maxSuffix)); if (publisher) len += ccnl_ccnb_mkField(out + len, CCN_DTAG_PUBPUBKDIGEST, CCN_TT_BLOB, publisher, plen); if (scope) len += ccnl_ccnb_mkField(out + len, CCN_DTAG_SCOPE, CCN_TT_UDATA, (unsigned char*) scope, strlen(scope)); if (nonce) len += ccnl_ccnb_mkField(out + len, CCN_DTAG_NONCE, CCN_TT_UDATA, (unsigned char*) nonce, sizeof(*nonce)); out[len++] = 0; // end-of-interest return len; }
int mkNewEthDevRequest(unsigned char *out, char *devname, char *ethtype, char *frag, char *flags, char *private_key_path) { int len = 0, len1 = 0, len2 = 0, len3 = 0; unsigned char out1[CCNL_MAX_PACKET_SIZE]; unsigned char contentobj[2000]; unsigned char faceinst[2000]; len = ccnl_ccnb_mkHeader(out, CCN_DTAG_INTEREST, CCN_TT_DTAG); // interest len += ccnl_ccnb_mkHeader(out+len, CCN_DTAG_NAME, CCN_TT_DTAG); // name len1 += ccnl_ccnb_mkStrBlob(out1+len1, CCN_DTAG_COMPONENT, CCN_TT_DTAG, "ccnx"); len1 += ccnl_ccnb_mkStrBlob(out1+len1, CCN_DTAG_COMPONENT, CCN_TT_DTAG, ""); len1 += ccnl_ccnb_mkStrBlob(out1+len1, CCN_DTAG_COMPONENT, CCN_TT_DTAG, "newdev"); // prepare DEVINSTANCE len3 = ccnl_ccnb_mkHeader(faceinst, CCNL_DTAG_DEVINSTANCE, CCN_TT_DTAG); len3 += ccnl_ccnb_mkStrBlob(faceinst+len3, CCN_DTAG_ACTION, CCN_TT_DTAG, "newdev"); if (devname) len3 += ccnl_ccnb_mkStrBlob(faceinst+len3, CCNL_DTAG_DEVNAME, CCN_TT_DTAG, devname); if (ethtype) len3 += ccnl_ccnb_mkStrBlob(faceinst+len3, CCN_DTAG_PORT, CCN_TT_DTAG, ethtype); if (frag) len3 += ccnl_ccnb_mkStrBlob(faceinst+len3, CCNL_DTAG_FRAG, CCN_TT_DTAG, frag); if (flags) len3 += ccnl_ccnb_mkStrBlob(faceinst+len3, CCNL_DTAG_DEVFLAGS, CCN_TT_DTAG, flags); faceinst[len3++] = 0; // end-of-faceinst // prepare CONTENTOBJ with CONTENT len2 = ccnl_ccnb_mkHeader(contentobj, CCN_DTAG_CONTENTOBJ, CCN_TT_DTAG); // contentobj len2 += ccnl_ccnb_mkBlob(contentobj+len2, CCN_DTAG_CONTENT, CCN_TT_DTAG, // content (char*) faceinst, len3); contentobj[len2++] = 0; // end-of-contentobj // add CONTENTOBJ as the final name component len1 += ccnl_ccnb_mkBlob(out1+len1, CCN_DTAG_COMPONENT, CCN_TT_DTAG, // comp (char*) contentobj, len2); #ifdef USE_SIGNATURES if(private_key_path) len += add_signature(out+len, private_key_path, out1, len1); #endif /*USE_SIGNATURES*/ memcpy(out+len, out1, len1); len += len1; out[len++] = 0; // end-of-name out[len++] = 0; // end-of-interest return len; }
static int ccnl_crypto_create_ccnl_sign_verify_msg(char *typ, int txid, char *content, int content_len, char *sig, int sig_len, char *msg, char *callback) { int len = 0, len2 = 0, len3 = 0; char *component_buf, *contentobj_buf; char h[100]; component_buf = ccnl_malloc(sizeof(char)*(content_len)+2000); contentobj_buf = ccnl_malloc(sizeof(char)*(content_len)+1000); len = ccnl_ccnb_mkHeader(msg, CCN_DTAG_INTEREST, CCN_TT_DTAG); // interest len += ccnl_ccnb_mkHeader(msg+len, CCN_DTAG_NAME, CCN_TT_DTAG); // name len += ccnl_ccnb_mkStrBlob(msg+len, CCN_DTAG_COMPONENT, CCN_TT_DTAG, "ccnx"); len += ccnl_ccnb_mkStrBlob(msg+len, CCN_DTAG_COMPONENT, CCN_TT_DTAG, "crypto"); // prepare FACEINSTANCE len3 += ccnl_ccnb_mkStrBlob(component_buf+len3, CCNL_DTAG_CALLBACK, CCN_TT_DTAG, callback); len3 += ccnl_ccnb_mkStrBlob(component_buf+len3, CCN_DTAG_TYPE, CCN_TT_DTAG, typ); memset(h, 0, 100); sprintf(h, "%d", txid); len3 += ccnl_ccnb_mkStrBlob(component_buf+len3, CCN_DTAG_SEQNO, CCN_TT_DTAG, h); if(!strcmp(typ, "verify")) len3 += ccnl_ccnb_mkBlob(component_buf+len3, CCN_DTAG_SIGNATURE, CCN_TT_DTAG, // content (char*) sig, sig_len); len3 += ccnl_ccnb_mkBlob(component_buf+len3, CCN_DTAG_CONTENTDIGEST, CCN_TT_DTAG, // content (char*) content, content_len); // prepare CONTENTOBJ with CONTENT len2 = ccnl_ccnb_mkHeader(contentobj_buf, CCN_DTAG_CONTENTOBJ, CCN_TT_DTAG); // contentobj len2 += ccnl_ccnb_mkBlob(contentobj_buf+len2, CCN_DTAG_CONTENT, CCN_TT_DTAG, // content (char*) component_buf, len3); contentobj_buf[len2++] = 0; // end-of-contentobj // add CONTENTOBJ as the final name component len += ccnl_ccnb_mkBlob(msg+len, CCN_DTAG_COMPONENT, CCN_TT_DTAG, // comp (char*) contentobj_buf, len2); msg[len++] = 0; // end-of-name msg[len++] = 0; // end-o ccnl_free(component_buf); ccnl_free(contentobj_buf); return len; }
static int ccnl_crypto_add_signature(unsigned char *out, char *sig, int siglen) { int len; len = ccnl_ccnb_mkHeader(out, CCN_DTAG_SIGNATURE, CCN_TT_DTAG); len += ccnl_ccnb_mkStrBlob(out + len, CCN_DTAG_NAME, CCN_TT_DTAG, "SHA256"); len += ccnl_ccnb_mkStrBlob(out + len, CCN_DTAG_WITNESS, CCN_TT_DTAG, ""); //add signaturebits bits... len += ccnl_ccnb_mkHeader(out + len, CCN_DTAG_SIGNATUREBITS, CCN_TT_DTAG); len += ccnl_ccnb_addBlob(out + len, sig, siglen); out[len++] = 0; // end signaturebits out[len++] = 0; // end signature return len; }
int mkDebugRequest(unsigned char *out, char *dbg, char *private_key_path) { int len = 0, len1 = 0, len2 = 0, len3 = 0; unsigned char out1[CCNL_MAX_PACKET_SIZE]; unsigned char contentobj[2000]; unsigned char stmt[1000]; len = ccnl_ccnb_mkHeader(out, CCN_DTAG_INTEREST, CCN_TT_DTAG); // interest len += ccnl_ccnb_mkHeader(out+len, CCN_DTAG_NAME, CCN_TT_DTAG); // name len1 += ccnl_ccnb_mkStrBlob(out1+len1, CCN_DTAG_COMPONENT, CCN_TT_DTAG, "ccnx"); len1 += ccnl_ccnb_mkStrBlob(out1+len1, CCN_DTAG_COMPONENT, CCN_TT_DTAG, ""); len1 += ccnl_ccnb_mkStrBlob(out1+len1, CCN_DTAG_COMPONENT, CCN_TT_DTAG, "debug"); // prepare debug statement len3 = ccnl_ccnb_mkHeader(stmt, CCNL_DTAG_DEBUGREQUEST, CCN_TT_DTAG); len3 += ccnl_ccnb_mkStrBlob(stmt+len3, CCN_DTAG_ACTION, CCN_TT_DTAG, "debug"); len3 += ccnl_ccnb_mkStrBlob(stmt+len3, CCNL_DTAG_DEBUGACTION, CCN_TT_DTAG, dbg); stmt[len3++] = 0; // end-of-debugstmt // prepare CONTENTOBJ with CONTENT len2 = ccnl_ccnb_mkHeader(contentobj, CCN_DTAG_CONTENTOBJ, CCN_TT_DTAG); // contentobj len2 += ccnl_ccnb_mkBlob(contentobj+len2, CCN_DTAG_CONTENT, CCN_TT_DTAG, // content (char*) stmt, len3); contentobj[len2++] = 0; // end-of-contentobj // add CONTENTOBJ as the final name component len1 += ccnl_ccnb_mkBlob(out1+len1, CCN_DTAG_COMPONENT, CCN_TT_DTAG, // comp (char*) contentobj, len2); #ifdef USE_SIGNATURES if(private_key_path) len += add_signature(out+len, private_key_path, out1, len1); #endif /*USE_SIGNATURES*/ memcpy(out+len, out1, len1); len += len1; out[len++] = 0; // end-of-name out[len++] = 0; // end-of-interest // ccnl_prefix_free(p); return len; }
int add_ccnl_name(unsigned char *out, char *ccn_path) { char comp[256]; int len = 0, len2 = 0; int h; memset(comp, 0 , 256); len += ccnl_ccnb_mkHeader(out + len, CCN_DTAG_NAME, CCN_TT_DTAG); while( (h = split_string(ccn_path + len2, '/', comp)) ) { len2 += h; len += ccnl_ccnb_mkStrBlob(out + len, CCN_DTAG_COMPONENT, CCN_TT_DTAG, comp); memset(comp, 0 , 256); } out[len++] = 0; return len; }
int ccnl_mgmt_crypto(struct ccnl_relay_s *ccnl, char *type, unsigned char *buf, int buflen) { struct ccnl_face_s *from; DEBUGMSG(DEBUG,"ccnl_crypto type: %s\n", type); if(!strcmp(type, "verify")){ int seqnum = 0; int verified = ccnl_crypto_extract_verify_reply(&buf, &buflen, &seqnum); unsigned char *msg, *msg2; char cmd[500]; int len = ccnl_crypto_extract_msg(&buf, &buflen, &msg), len2 = 0; struct ccnl_face_s *from; //DEBUGMSG(DEBUG,"VERIFIED: %d, MSG_LEN: %d\n", verified, len); int scope=3, aok=3, minsfx=0, maxsfx=CCNL_MAX_NAME_COMP, contlen; struct ccnl_buf_s *buf1 = 0, *nonce=0, *ppkd=0; struct ccnl_prefix_s *p = 0; struct ccnl_buf_s *msg2_buf; unsigned char *content = 0; msg2 = (char *) ccnl_malloc(sizeof(char) * len + 200); len2 = ccnl_ccnb_mkHeader(msg2,CCN_DTAG_NAME, CCN_TT_DTAG); memcpy(msg2+len2, msg, len); len2 +=len; msg2[len2++] = 0; from = ccnl->faces; while(from){ if(from->faceid == seqnum) break; from = from->next; } buf1 = ccnl_ccnb_extract(&msg2, &len2, &scope, &aok, &minsfx, &maxsfx, &p, &nonce, &ppkd, &content, &contlen); if (p->complen[2] < sizeof(cmd)) { memcpy(cmd, p->comp[2], p->complen[2]); cmd[p->complen[2]] = '\0'; } else strcpy(cmd, "cmd-is-too-long-to-display"); msg2_buf = ccnl_buf_new((char *)msg2, len2); ccnl_mgmt_handle(ccnl, msg2_buf, p, from, cmd, verified); ccnl_free(msg2_buf); }else if(!strcmp(type, "sign")){ char *sig = (char *) ccnl_malloc(sizeof(char)* CCNL_MAX_PACKET_SIZE); unsigned char *out; unsigned char *msg; int siglen = 0, seqnum = 0, len, len1; struct ccnl_buf_s *retbuf; ccnl_crypto_extract_sign_reply(&buf, &buflen, sig, &siglen, &seqnum); len = ccnl_crypto_extract_msg(&buf, &buflen, &msg); out = (char *) ccnl_malloc(sizeof(unsigned char)*len + sizeof(unsigned char)*siglen + 4096); len1 = ccnl_ccnb_mkHeader(out, CCN_DTAG_CONTENTOBJ, CCN_TT_DTAG); // content if(siglen > 0) len1 += ccnl_crypto_add_signature(out+len1, sig, siglen); memcpy(out+len1, msg, len); len1 +=len; out[len1++] = 0; // end-of-interest from = ccnl->faces; while(from){ if(from->faceid == seqnum) break; from = from->next; } retbuf = ccnl_buf_new((char *)out, len1); if(seqnum >= 0){ ccnl_face_enqueue(ccnl, from, retbuf); }else{ struct ccnl_prefix_s *prefix_a = 0; struct ccnl_content_s *c = 0; struct ccnl_buf_s *nonce=0, *ppkd=0, *pkt = 0; unsigned char *content = 0; char *ht = (char *) ccnl_malloc(sizeof(char)*20); int contlen; pkt = ccnl_ccnb_extract(&out, &len1, 0, 0, 0, 0, &prefix_a, &nonce, &ppkd, &content, &contlen); if (!pkt) { DEBUGMSG(WARNING, " parsing error\n"); goto Done; } if (prefix_a) { //DEBUGMSG(DEBUG, "%s", prefix_a->comp); //ccnl_free(prefix_a); } //prefix_a = (struct ccnl_prefix_s *)ccnl_malloc(sizeof(struct ccnl_prefix_s)); prefix_a->compcnt = 2; prefix_a->comp = (unsigned char **) ccnl_malloc(sizeof(unsigned char*)*2); prefix_a->comp[0] = "mgmt"; sprintf(ht, "seqnum-%d", -seqnum); prefix_a->comp[1] = ht; prefix_a->complen = (int *) ccnl_malloc(sizeof(int)*2); prefix_a->complen[0] = strlen("mgmt"); prefix_a->complen[1] = strlen(ht); c = ccnl_content_new(ccnl, CCNL_SUITE_CCNB, &pkt, &prefix_a, &ppkd, content, contlen); if (!c) goto Done; ccnl_content_serve_pending(ccnl, c); ccnl_content_add2cache(ccnl, c); } Done: ccnl_free(out); } return 0; }
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 = ccnl_ccnb_mkHeader(header, CCNL_DTAG_FRAGMENT2013, CCN_TT_DTAG); // fragment hdrlen += ccnl_ccnb_mkHeader(header + hdrlen, CCNL_DTAG_FRAG2013_TYPE, CCN_TT_DTAG); hdrlen += ccnl_ccnb_mkHeader(header + hdrlen, 3, CCN_TT_BLOB); memcpy(header + hdrlen, CCNL_FRAG_TYPE_CCNx2013_VAL, 3); // "FHBH" header[hdrlen + 3] = '\0'; hdrlen += 4; hdrlen += ccnl_ccnb_mkBinaryInt(header+hdrlen, CCNL_DTAG_FRAG2013_SEQNR, CCN_TT_DTAG, fr->sendseq, fr->sendseqwidth); hdrlen += ccnl_ccnb_mkBinaryInt(header+hdrlen, CCNL_DTAG_FRAG2013_FLAGS, CCN_TT_DTAG, 0, fr->flagwidth); flagoffs = hdrlen - 2; // most significant byte of flag element // other optional fields would go here hdrlen += ccnl_ccnb_mkHeader(header+hdrlen, CCN_DTAG_CONTENT, CCN_TT_DTAG); blobtaglen = ccnl_ccnb_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 += ccnl_ccnb_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_EFRA(TRACE, "ccnl_frag_getnextSEQD2012 e=%p, mtu=%d\n", (void*)e, e->mtu); DEBUGMSG_EFRA(TRACE, " %d bytes to fragment, offset=%d\n", e->bigpkt->datalen, e->sendoffs); hdrlen = ccnl_ccnb_mkHeader(header, CCNL_DTAG_FRAGMENT2012, CCN_TT_DTAG); hdrlen += ccnl_ccnb_mkBinaryInt(header + hdrlen, CCNL_DTAG_FRAG2012_FLAGS, CCN_TT_DTAG, 0, e->flagwidth); flagoffs = hdrlen - 2; hdrlen += ccnl_ccnb_mkBinaryInt(header + hdrlen, CCNL_DTAG_FRAG2012_YSEQN, CCN_TT_DTAG, e->recvseq, e->recvseqwidth); hdrlen += ccnl_ccnb_mkBinaryInt(header+hdrlen, CCNL_DTAG_FRAG2012_OLOSS, CCN_TT_DTAG, e->losscount, e->losscountwidth); hdrlen += ccnl_ccnb_mkBinaryInt(header + hdrlen, CCNL_DTAG_FRAG2012_SEQNR, CCN_TT_DTAG, e->sendseq, e->sendseqwidth); hdrlen += ccnl_ccnb_mkHeader(header+hdrlen, CCN_DTAG_CONTENT, CCN_TT_DTAG); blobtaglen = ccnl_ccnb_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 += ccnl_ccnb_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_EFRA(TRACE, " e->offset now %d\n", e->sendoffs); if (ifndx) *ifndx = e->ifndx; if (su) memcpy(su, &e->dest, sizeof(*su)); return buf; }
int ccnl_frag_getfragcount(struct ccnl_frag_s *e, int origlen, int *totallen) { int cnt = 0, len = 0; if (!e) cnt = 1; #ifdef OBSOLETE_BY_2015_06 #ifdef USE_SUITE_CCNB else if (e->protocol == CCNL_FRAG_SEQUENCED2012) { unsigned char dummy[256]; int hdrlen, blobtaglen, datalen; int offs = 0; while (offs < origlen) { // we could do better than to simulate this: hdrlen = ccnl_ccnb_mkHeader(dummy, CCNL_DTAG_FRAGMENT2012, CCN_TT_DTAG); hdrlen += ccnl_ccnb_mkBinaryInt(dummy, CCNL_DTAG_FRAG2012_FLAGS, CCN_TT_DTAG, 0, e->flagwidth); hdrlen += ccnl_ccnb_mkBinaryInt(dummy, CCNL_DTAG_FRAG2012_SEQNR, CCN_TT_DTAG, 0, e->sendseqwidth); hdrlen += ccnl_ccnb_mkBinaryInt(dummy, CCNL_DTAG_FRAG2012_OLOSS, CCN_TT_DTAG, 0, e->losscountwidth); hdrlen += ccnl_ccnb_mkBinaryInt(dummy, CCNL_DTAG_FRAG2012_YSEQN, CCN_TT_DTAG, 0, e->recvseqwidth); hdrlen += ccnl_ccnb_mkHeader(dummy, CCN_DTAG_CONTENT, CCN_TT_DTAG); blobtaglen = ccnl_ccnb_mkHeader(dummy, e->mtu - hdrlen - 1, CCN_TT_BLOB); datalen = e->mtu - hdrlen - blobtaglen - 1; if (datalen > (origlen - offs)) datalen = origlen - offs; hdrlen += ccnl_ccnb_mkHeader(dummy, datalen, CCN_TT_BLOB); len += hdrlen + datalen + 1; offs += datalen; cnt++; } } else if (e->protocol == CCNL_FRAG_CCNx2013) { unsigned char dummy[256]; int hdrlen, blobtaglen, datalen; int offs = 0; while (offs < origlen) { // we could do better than to simulate this: hdrlen = ccnl_ccnb_mkHeader(dummy, CCNL_DTAG_FRAGMENT2013, CCN_TT_DTAG); hdrlen += ccnl_ccnb_mkHeader(dummy, CCNL_DTAG_FRAG2013_TYPE, CCN_TT_DTAG); hdrlen += 4; // three BLOB bytes plus end-of-entry hdrlen += ccnl_ccnb_mkBinaryInt(dummy, CCNL_DTAG_FRAG2013_SEQNR, CCN_TT_DTAG, 0, e->sendseqwidth); hdrlen += ccnl_ccnb_mkBinaryInt(dummy, CCNL_DTAG_FRAG2013_FLAGS, CCN_TT_DTAG, 0, e->flagwidth); hdrlen += ccnl_ccnb_mkBinaryInt(dummy, CCNL_DTAG_FRAG2013_OLOSS, CCN_TT_DTAG, 0, e->losscountwidth); hdrlen += ccnl_ccnb_mkBinaryInt(dummy, CCNL_DTAG_FRAG2013_YSEQN, CCN_TT_DTAG, 0, e->recvseqwidth); hdrlen += ccnl_ccnb_mkHeader(dummy, CCN_DTAG_CONTENT, CCN_TT_DTAG); blobtaglen = ccnl_ccnb_mkHeader(dummy, e->mtu - hdrlen - 1, CCN_TT_BLOB); datalen = e->mtu - hdrlen - blobtaglen - 1; if (datalen > (origlen - offs)) datalen = origlen - offs; hdrlen += ccnl_ccnb_mkHeader(dummy, datalen, CCN_TT_BLOB); len += hdrlen + datalen + 1; offs += datalen; cnt++; } } #endif else if (e->protocol == CCNL_FRAG_SEQUENCED2015) { // ... DEBUGMSG_EFRA(FATAL, "frag counting not implemented yet for SEQD2015!\n"); } #endif // OBSOLETE else { DEBUGMSG_EFRA(FATAL, "frag protocol %d not supported?\n", e->protocol); } if (totallen) *totallen = len; return cnt; }