Sender: Pluggable fec methods

Author: Spritetm

common/structs.h

@@ -21,6 +21,18 @@ typedef struct {
 }  __attribute__ ((packed)) FecPacket;
 
 
+//A serial of 0 means something special: it defines the FEC parameters in use.
+typedef struct {
+	uint16_t k;
+	uint16_t n;
+	uint8_t fecAlgoId;
+} __attribute__ ((packed)) FecDesc;
+
+
+#define FEC_ID_PARITY 0 //Simple parity addition
+#define FEC_ID_RS 1     //Reed-Solomon with tsd's code
+
+
 //Randomly chosen
 #define SERDES_MAGIC 0x1A014AF5
 
@@ -113,3 +125,7 @@ typedef struct {
 } __attribute__ ((packed)) BDPacketChange;
 
 
+/*
+
+*/
+

server/Makefile

@@ -1,4 +1,4 @@
-OBJS=main.o sender.o fec.o serdes.o ../common/crc16.o sha256.o uECC.o sign-ed25519.o packetloss.o hlmux.o
+OBJS=main.o sender.o fec.o serdes.o ../common/crc16.o sha256.o uECC.o sign-ed25519.o packetloss.o hlmux.o fec_parity.o
 TARGET=bppsender
 CFLAGS=-ggdb -std=gnu99 -I ../common -I ../micro-ecc -I ../sha256 -ggdb -I ../ed25519/src
 LDFLAGS=../ed25519/src/libed25519.a

server/fec.c

@@ -15,14 +15,22 @@ parity packet.
 #include "sendif.h"
 #include "structs.h"
 #include <time.h>
+#include "fec.h"
 
-//Emit a parity packet every FEC_M packets
-#define FEC_M 3
+extern FecGenerator fecGenParity;
+
+static FecGenerator *gens[]={
+	&fecGenParity,
+	NULL
+};
+
+static FecGenerator *currGen=NULL;
+
+static int currK, currN;
 
 static int sendMaxPktLen;
 static SendCb *sendCb;
 static int serial=0;
-static uint8_t *parPacket;
 
 static time_t tsLastSaved;
 
@@ -31,50 +39,52 @@ static time_t tsLastSaved;
 void fecInit(SendCb *cb, int maxlen) {
 	sendCb=cb;
 	sendMaxPktLen=maxlen;
-	parPacket=malloc(maxlen);
-	memset(parPacket, 0, maxlen);
 	char buff[128];
 	FILE *f=fopen(TSFILE, "r");
 	if (f!=NULL) {
 		fgets(buff, 127, f);
 		serial=atoi(buff);
 		fclose(f);
 	}
+	if (serial==0) serial=1; //because serial==0 is special
 	tsLastSaved=time(NULL);
+	currGen=gens[0];
+	currK=3;
+	currN=4;
+	currGen->init(currK, currN, maxlen);
 }
 
-
-void fecSend(uint8_t *packet, size_t len) {
-	int fecMaxPacketLen=(sendMaxPktLen-sizeof(FecPacket)); //max data in a fec packet
-	FecPacket *p=malloc(sizeof(FecPacket)+fecMaxPacketLen);
+void fecSendFecced(uint8_t *packet, size_t len) {
+	FecPacket *p=malloc(sizeof(FecPacket)+len);
 	p->serial=htonl(serial);
 	memcpy(p->data, packet, len);
-	//Clear rest of packet to not leak stuff
-	memset(p->data+len, 0, fecMaxPacketLen-len);
-	//Add packet to parity
-	for (int x=0; x<fecMaxPacketLen; x++) parPacket[x]^=p->data[x];
-	sendCb((uint8_t*)p, sendMaxPktLen);
+	sendCb((uint8_t*)p, sizeof(FecPacket)+len);
 	serial++;
-	//See if it's time to send the parity packet already.
-	if ((serial % (FEC_M+1)) == FEC_M) {
-		//Yes it is! Re-use p to send parity data.
-		p->serial=htonl(serial);
-		memcpy(p->data, parPacket, fecMaxPacketLen);
-		sendCb((uint8_t*)p, sendMaxPktLen);
-		serial++;
-		//Zero out parity array for next set of packets.
-		memset(parPacket, 0, fecMaxPacketLen);
-	}
-	//Save timestamp in case of crash/quit every 10 secs
+	free(p);
+}
+
+
+void fecSend(uint8_t *packet, size_t len) {
+	currGen->send(packet, len, serial, fecSendFecced);
+	//Save timestamp every 10 secs in case of crash/quit
 	if (time(NULL)-tsLastSaved > 10) {
 		FILE *f;
 		f=fopen(TSFILE".tmp", "w");
 		fprintf(f, "%d", (int)serial);
 		fclose(f);
 		rename(TSFILE".tmp", TSFILE);
 		tsLastSaved=time(NULL);
+
+		//Semi-hack: We use the same timer to send out the FEC parameters
+		FecPacket *p=malloc(sizeof(FecPacket)+sizeof(FecDesc));
+		p->serial=htonl(0);
+		FecDesc *dsc=(FecDesc*)p->data;
+		dsc->k=htons(currK);
+		dsc->n=htons(currN);
+		dsc->fecAlgoId=currGen->genId;
+		sendCb(p, sizeof(FecPacket)+sizeof(FecDesc));
+		free(p);
 	}
-	free(p);
 }
 
 

server/fec.h

@@ -3,6 +3,23 @@
 
 #include "sendif.h"
 
+typedef void (*FecSendFeccedPacket)(uint8_t *packet, size_t len);
+
+//WARNING: it is assumed that every packet sent through these functions will have length=maxsize
+//Emit n packets out for every k packets in
+typedef int (*FecGeneratorInit)(int k, int n, int maxsize);
+typedef int (*FecGeneratorSend)(uint8_t *packet, size_t len, int serial, FecSendFeccedPacket sendfn);
+typedef void (*FecGeneratorDeinit)();
+typedef struct {
+	const char *name;
+	const char *desc;
+	const int genId;
+	FecGeneratorInit init;
+	FecGeneratorSend send;
+	FecGeneratorDeinit deinit;
+} FecGenerator;
+
+
 void fecInit(SendCb *cb, int maxlen);
 int fecGetMaxPacketLength();
 void fecSend(uint8_t *packet, size_t len);

server/fec_parity.c

@@ -0,0 +1,52 @@
+#include <stdint.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "sendif.h"
+#include "structs.h"
+#include "fec.h"
+
+
+static uint8_t *parPacket;
+int parM; //after how many packets to send a parity packet
+int biggestLen=0;
+
+int parInit(int k, int n, int maxsize) {
+	if (n!=k+1) return 0;
+	parM=k;
+	parPacket=malloc(maxsize);
+	memset(parPacket, 0, maxsize);
+	biggestLen=0;
+	return 1;
+}
+
+int parSend(uint8_t *packet, size_t len, int serial, FecSendFeccedPacket sendFn) {
+	//Add to parity packet
+	for (int i=0; i<len; i++) parPacket[i]^=packet[i];
+	if (biggestLen<len) biggestLen=len;
+	//Send packet
+	sendFn(packet, len);
+	//See if we need to send parity packet
+	int p=serial%(parM+1);
+	if (p==parM) {
+		sendFn(parPacket, biggestLen);
+		memset(parPacket, 0, biggestLen);
+		biggestLen=0;
+	}
+	return 1;
+}
+
+void parDeinit() {
+	free(parPacket);
+	return;
+}
+
+FecGenerator fecGenParity={
+	.name="parity",
+	.desc="Single parity packet. N must be K+1; K can be arbitrary.",
+	.genId=FEC_ID_PARITY,
+	.init=parInit,
+	.send=parSend,
+	.deinit=parDeinit,
+};
+