/ - Diff - PeerStreamer - Redmine

Revision 5f3adef4

     /*
      ============================================================================
      Name        : ALTOclient.c
      Authors     : Thilo Ewald
     			   Armin Jahanpanah <jahanpanah@neclab.eu>
      Author      : T. Ewald <ewald@nw.neclab.eu>
      Version     : 243
      Proprietary : NEC Europe Ltd. PROPRIETARY INFORMATION
     			   This software is supplied under the terms of a license
     			   agreement or nondisclosure agreement with NEC Europe Ltd. and
-...
     			   OUT OF THE USE OF OR INABILITY TO USE THIS PROGRAM, EVEN IF NEC
     			   Europe Ltd. HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
      Modification: THIS HEADER MAY NOT BE EXTRACTED OR MODIFIED IN ANY WAY.
      Description : First try of the ALTO client
      ============================================================================
      */
     #include "ALTOclient.h"
     #include "ALTOclient_impl.h"
     #include <stddef.h>
     #include <stdarg.h>
     #include <pthread.h>
     #include <sys/time.h>
     #include <time.h>
     typedef struct {
     	int query_failure_count;
     	int query_failure_count_total;
     } alto_stats;
     static alto_stats stats;
     /*
      * 		Here the reference to the accessible DBs is set
-...
     static xmlDocPtr ALTO_XML_req = NULL;		// Pointer to the XML for the Request
     static xmlDocPtr ALTO_XML_res = NULL;		// Pointer to the XML for the Request
     // This is the varaiable where the ALTO server can be found
     static char alto_server_url[256];
-...
     #define returnIf(expr, msg, retval) if(expr) { alto_errorf("%s - Condition check: '"#expr"' (%s, line: %d) -- %s\n", __FUNCTION__, __FILE__, __LINE__, msg); return retval; }
     #define errorMsg(msg) alto_errorf("%s (%s, line: %d) -- %s\n", __FUNCTION__, __FILE__, __LINE__, msg);
     typedef struct {
     	uint64_t timer_start;	/* time of init */
     	uint64_t timer_last;	/* time of last update */
     	uint64_t timer_delta;	/* timespan between last two updates */
     	uint64_t ticks;			/* microsecs since timer_start */
     	float t;				/* seconds since timer start */
     	float dt;				/* timer_delta in seconds */
     } alto_timer;
     static void alto_timer_init(alto_timer* timer)
+    {
     	struct timeval tnow;
     	gettimeofday(&tnow, NULL);
     	timer->timer_start = (tnow.tv_usec + tnow.tv_sec * 1000000ull);
     	timer->timer_last = timer->timer_start;
     	timer->timer_delta = 0;
     	timer->ticks = 0;
     	timer->t = 0.0f;
     	timer->dt = 0.0f;
+    }
     static void alto_timer_update(alto_timer* timer)
+    {
     	struct timeval tnow;
     	gettimeofday(&tnow, NULL);
     	uint64_t timer_now = (tnow.tv_usec + tnow.tv_sec * 1000000ull);
     	timer->timer_delta = timer_now - timer->timer_last;
     	timer->timer_last = timer_now;
     	timer->ticks = timer_now - timer->timer_start;
     	timer->t = timer->ticks / 1000000.0f; /* in seconds */
     	timer->dt = timer->timer_delta / 1000000.0f; /* in seconds */
+    }
     /*
      * 	Function to set the actual ALTO server for configuration
      */
-...
     	return (char *) alto_server_url;
+    }
     /*
      * 	Func:					Convert the "Baschtl" notation into a readable
      * 							format (get IP address)
-...
     	return IP;
+    }
     /*
      * 	Func:			Convert the "Baschtl" notation into a readable format
      * 					(get prefix)
-...
         return 32;
+    }
     /*
      *  Func:	Create an ALTO XML request from a given DB
+     *
-...
      *  ret:	XML_doc		the XML where the request is stored in
      */
     xmlDocPtr alto_create_request_XML(struct alto_db_t * db, struct in_addr rc_host, int pri_rat, int sec_rat){
     	returnIf(db == NULL, "internal db ptr is NULL!", NULL);
     	assertCheck(db, "internal db ptr is NULL!");
     	// Creates a new document
     	// <?xml version="1.0" encoding="UTF-8"?>
     	xmlDocPtr doc = NULL;       /* document pointer */
     	doc = xmlNewDoc(BAD_CAST "1.0");
     	returnIf(doc == NULL, "xmlNewDoc failed! Out of memory?", NULL);
     	assertCheck(doc, "xmlNewDoc failed! Out of memory?");
     	// Create the root node and name it with the correct name space
     	// <alto xmlns='urn:ietf:params:xml:ns:p2p:alto'>
-...
         	xmlNewProp(node_PRI, BAD_CAST "crit", BAD_CAST "lat");
+        }
         // Add the additional rating criteria
     	if((sec_rat & REL_PREF) == REL_PREF){
     		xmlNodePtr node_SEC1 = NULL;
-...
     		xmlNewProp(node_SEC4, BAD_CAST "crit", BAD_CAST "lat");
+    	}
         // Now create the source of the request
         // <rc_hla><ipprefix version='4' prefix='195.37.70.39/32'/></rc_hla>
         xmlNodePtr node_RC_HLA = NULL;
-...
            libCURL-based POST code
       ==================================*/
     // libcurl is now obsolete!
     #ifdef USE_CURL
     // this function will be registered with curl as a handler, which
     // copies the http reply to a the buffer
     static size_t curl_copy_reply_to_buf(void *ptr,size_t size,size_t nmemb,void *stream){
     size_t curl_copy_reply_to_buf(void *ptr,size_t size,size_t nmemb,void *stream){
         size_t realsize = size * nmemb;
         struct curl_reply_buffer_t *crb = (struct curl_reply_buffer_t *)stream;
         // error: new chunk plus trailing zero would not fit into remaining buffer
-...
+    }
     uint16_t prefixes = 0;
     xmlDocPtr query_ALTO_server_curl(xmlDocPtr doc, char* ALTO_server_URL){
     	xmlDocPtr ALTO_XML_response;
-...
     	struct curl_httppost *lastptr=NULL;
     	curl = curl_easy_init();
     	returnIf(curl == NULL, "Couldn't get a handle from curl_easy_init(). abort.", NULL);
     	assertCheck(curl, "Couldn't get a handle from curl_easy_init(). abort.");
     	//printf("Will send HTTP POST to %s\nwith form data:\n\n%s\n", alto_server_url, ALTO_XML_query);
     //	printf("Will send HTTP POST to %s\nwith form data:\n\n%s\n", alto_server_url, ALTO_XML_query);
     	// prepare the buffer to be send
     	xmlChar*  doctxt;
     	int       doclen;
     	xmlDocDumpFormatMemoryEnc(doc,&doctxt,&doclen,"utf-8",1);
     	#ifdef USE_DEBUG_OUTPUT
     	printf(stderr, "[ALTOclientCURL] Will send HTTP POST to %s\nwith XML data:\n\n%s\n", alto_server_url, doctxt);
     	#endif
     	// URL that receives this POST
     	curl_easy_setopt(curl, CURLOPT_URL, ALTO_server_URL);
     //	curl_easy_setopt(curl, CURLOPT_TCP_NODELAY, 1);
     //	curl_easy_setopt(curl, CURLOPT_FORBID_REUSE, 1);
     	curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0);
     	// add form data
     	curl_formadd(&formpost,
     				 &lastptr,
     				 CURLFORM_COPYNAME, "alto_xml_request",
     //				 CURLFORM_COPYCONTENTS, ALTO_XML_query,
     				 CURLFORM_COPYCONTENTS, doctxt,		// PTRCONTENTS?
     				 CURLFORM_COPYCONTENTS, doctxt,
     				 CURLFORM_END);
     	curl_formadd(&formpost,
-...
     	// then cleanup the form post chain
     	curl_formfree(formpost);
     	#ifdef USE_DEBUG_OUTPUT
     	//printf("result of curl_easy_perform() is: %i\n", res);
     	fprintf(stderr, "[ALTOclientCURL] received %i octets. the buffer is:\n\n%s\nthat's all. bye.\n", alto_rep_buf.fill, alto_rep_buf.buffer);
     	#endif
     //  printf("result of curl_easy_perform() is: %i\n", res);
     //  printf("received %i octetts. the buffer is:\n\n%s\nthat's all. bye.\n",alto_rep_buf.fill,alto_rep_buf.buffer);
     	// and last but nor least, transform it into an XML doc
     	ALTO_XML_response = xmlRecoverMemory(alto_rep_buf.buffer, sizeof(alto_rep_buf.buffer));		// <- for getting XML from memory
     	ALTO_XML_response = xmlRecoverMemory(alto_rep_buf.buffer,sizeof(alto_rep_buf.buffer));		// <- for getting XML from memory
     	return ALTO_XML_response;
+    }
-...
     #define POST_BOUNDARY "---------------------------12408751047121013601852724877"
     static void POST_add(char* buf, const char* name, const char* value) {
     void POST_add(char* buf, const char* name, const char* value) {
     	sprintf(buf+strlen(buf), "--"POST_BOUNDARY"\r\nContent-Disposition: form-data; name=\"%s\"\r\n\r\n%s\r\n", name, value);
+    }
     static void POST_end(char* buf) {
     void POST_end(char* buf) {
     	sprintf(buf+strlen(buf), "--"POST_BOUNDARY"--\r\n\r\n");
+    }
     static void* POST_send(const char* url, const char* data) {
     void* POST_send(const char* url, const char* data) {
     	int i;
     	void* ctx = NULL;
     	char header[] = "Connection: close\r\n";
     	char contentType[] = "multipart/form-data; boundary="POST_BOUNDARY;
     	char* ct = contentType;
     	returnIf(url == NULL, "ALTO server URL is NULL!", NULL);
     	returnIf(data == NULL, "POST data is NULL!", NULL);
     	assertCheck(url, "ALTO server URL is NULL!");
     	assertCheck(data, "POST data is NULL!");
     	//ctx = xmlNanoHTTPMethod(url, "POST", data, &ct, NULL, strlen(data));
     	for (i=0; i < 3; i++) {
-...
     		fprintf(stderr, "URL was '%s'.", url);
     		return NULL;
+    	}
     	assertCheck(ctx, "xmlNanoHTTPMethod failed! Make sure ALTO server is reachable (NAT issue?)..");
     	free(ct);
     	return ctx;
-...
     //	int		errorcode = 0;
     //	FILE*	f = NULL;
     	returnIf(doc == NULL, "xml doc ptr is NULL!", NULL);
     	returnIf(endPoint == NULL, "ALTO server URL is NULL!", NULL);
     	assertCheck(doc, "xml doc ptr is NULL!");
     	assertCheck(endPoint, "ALTO server URL is NULL!");
     	xmlNanoHTTPInit();
     	xmlDocDumpFormatMemoryEnc(doc,&doctxt,&doclen,"utf-8",1);
     	dataLen = doclen + 2048;
     	data = malloc(dataLen);
     	returnIf(data == NULL, "Couldn't allocate data buffer! Out of memory?", NULL);
     	assertCheck(data, "Couldn't allocate data buffer! Out of memory?");
     	memset(data, 0, dataLen);
     	// build the mime multipart contents
-...
     	return result;
+    }
     /*
+     *
      * 		HERE is the magic for the internal DB management
-...
     	struct alto_db_t * db;
     	db = malloc(sizeof(struct alto_db_t));
     //	db = (alto_db_t *)malloc(sizeof(struct alto_db_element_t));
     	returnIf(db == NULL, "Couldn't allocate internal db! Out of memory?", NULL);
     	assertCheck(db, "Couldn't allocate internal db! Out of memory?");
     	db->first = NULL;
     	db->last = NULL;
-...
     	return 1;
+    }
     /*
      * 	Helper function to print values of one ALTO DB element
      */
     void alto_dump_element(struct alto_db_element_t * cur){
     	// Sanity check
     	if (cur == NULL) return;
     	assertCheck(cur == NULL, "No element to print values from! ABORT");
     	// normal case, print everything
     //	fprintf(stdout, "---> Internal Data\t");
-...
     	alto_debugf("Dump what's in the DB \n");
     	// Security Check
     	if (!db) return;
     	assertCheck(db, "Failure in DB structure! ABORT");
     	// General Data
     	alto_debugf("Number of elements in DB: %d \n", db->num_of_elements);
-...
     	return;
+    }
     /*
      *  Adds one ALTO entry to the DB
      */
-...
     		return 1;
+    	}
     	// normal handling, somwhere in the DB
     	else {
     		// update predecessor
-...
     	return -1;
+    }
     struct in_addr compute_subnet(struct in_addr host, int prefix){
     	struct in_addr subn;
     	uint32_t match_host = host.s_addr;
-...
     	return subn;
+    }
     /*
      * 	Search in an ALTO DB for the match of an host
+     *
-...
     	return 0;
+    }
     int ask_helper_func(struct in_addr subnet, ALTO_DB_T * db){
     	ALTO_DB_ELEMENT_T * cur = db->first;
     	while(cur != NULL){
-...
     	return 0;
+    }
     int get_alto_rating(ALTO_DB_ELEMENT_T * element, ALTO_DB_T * db){
     	int mask = element->host_mask;
-...
     	return 0;
+    }
     int get_alto_subnet_mask(ALTO_DB_ELEMENT_T * element, ALTO_DB_T * db){
     	int mask = element->host_mask;
     	struct in_addr subnet = compute_subnet(element->host, mask);
-...
     	return 0;
+    }
     /*
      * 	Here the matching between the requested IPs and the delivered
      * 	list will be done
-...
     	return 1;
+    }
     int alto_parse_from_file(altoDbPtr db, char *file_name){
     	alto_debugf("%s: Read hosts from file (%s) and store it in the Request-DB\n", __FUNCTION__, file_name);
-...
     	return 1;
+    }
     /*
      * 	Converts a given alto_list_t structure into the internal DB structure
+     *
-...
     	return 1;
+    }
     int alto_write_to_file(altoDbPtr db, char *file_name){
     	alto_debugf("%s: Write hosts to file (%s.out) \n", __FUNCTION__, file_name);
-...
     	return count;
+    }
     /*
      * 	Start & Innitialize the ALTO client
      */
-...
     	// prepare the XML environment
     	LIBXML_TEST_VERSION;
     #ifdef USE_CURL
     	// prepare CURL
     	// ---------------------------------------------------------------------------------
     	// XXX: NOTE:
     	// "This function is NOT THREAD SAFE. You must not call it when any other thread
     	// in the program (i.e. a thread sharing the same memory) is running. This doesn't
     	// just mean no other thread that is using libcurl. Because curl_global_init() calls
     	// functions of other libraries that are similarly thread unsafe, it could conflict
     	// with any other thread that uses these other libraries."
     	// ---------------------------------------------------------------------------------
     	curl_global_init(CURL_GLOBAL_ALL);
     #endif
     	// and Initialize the XMLs
         ALTO_XML_req = NULL;
         ALTO_XML_res = NULL;
     	// init query failure counters
     	stats.query_failure_count = 0;
         stats.query_failure_count_total = 0;
+    }
-...
         if (ALTO_XML_res) { xmlFreeDoc(ALTO_XML_res); ALTO_XML_res = NULL; }
     	xmlCleanupParser();
     #ifdef USE_CURL
     	// shutdown  libCurl
     	// XXX: NOTE: same thread un-safety warning applies!
     	curl_global_cleanup();
     #endif
+    }
     /*
      * 	Function:	gets for a list in a txt file the correct rating
+     *
-...
       ==================================*/
     static int queryState = ALTO_QUERY_READY;
     static alto_timer queryTimer;
     static pthread_t threadId;
     static pthread_attr_t attr;
-...
     	int sec_rat;
     } ALTO_ThreadArgs_t;
     static ALTO_ThreadArgs_t threadArgs;
     ALTO_ThreadArgs_t threadArgs;
     void* alto_query_thread_func(void* thread_args)
+    {
-...
     	alto_debugf("alto_query_thread_func\n");
     	// *** this will block at some point ***
     	do_ALTO_update(args->rc_host, args->pri_rat, args->sec_rat);	// BLOCK
     	// *** at this point we got the results from the ALTO server ***
         // reset counter of consecutive connection failures
         stats.query_failure_count = 0;
     	// this will block at some point
     	do_ALTO_update(args->rc_host, args->pri_rat, args->sec_rat);
     	// write values back
     	for(count = 0; count < args->num; count++){
-...
     	// signal that query is ready
     	queryState = ALTO_QUERY_READY;
     //	alto_timer_update(&queryTimer);
     //	alto_debugf("Query took %.2f seconds.\n", queryTimer.t);
     	return thread_args;
+    }
-...
     	return queryState;
+    }
     int ALTO_stats(int stat_id) {
     	if (stat_id == ALTO_STAT_FAILURE_COUNT) return stats.query_failure_count;
     	else if (stat_id == ALTO_STAT_FAILURE_COUNT_TOTAL) return  stats.query_failure_count_total;
     	return 0;
+    }
     int ALTO_query_exec(ALTO_GUIDANCE_T * list, int num, struct in_addr rc_host, int pri_rat, int sec_rat){
     	alto_debugf("ALTO_query_exec\n");
     	// Sanity checks (list)
     	returnIf(list == NULL, "Can't access the list!", 0);
     	returnIf(num < 0, "<0 elements?", 0);
     	int res = ALTO_QUERY_EXEC_OK;
     	// Sanity checks (num of elements)
     	returnIf(num < 0, "<0 elements?", 0);
     	// set new state
     	if (queryState == ALTO_QUERY_INPROGRESS) {
     		alto_timer_update(&queryTimer);
     		if (queryTimer.t < ALTO_TIMEOUT) {
     			alto_debugf("*** WARNING: Calling ALTO_query_exec while query is still in progress! Aborting..\n");
     			return ALTO_QUERY_EXEC_INPROGRESS;
+    		}
     		alto_debugf("*** NOTE: Previous ALTO_query_exec timed out (> %d sec.), starting new query..\n", ALTO_TIMEOUT);
     		res = ALTO_QUERY_EXEC_TIMEOUT;
     		// count connection failures
     		stats.query_failure_count++;
     		stats.query_failure_count_total++;
     		alto_debugf("total count of ALTO server query connection failures so far: %d\n", stats.query_failure_count_total);
     		alto_debugf("*** WARNING: Calling ALTO_query_exec while query is still in progress! Race condition?!\n");
     		return 0;
+    	}
     	queryState = ALTO_QUERY_INPROGRESS;
     	alto_timer_init(&queryTimer);
     	// first purge existing DB entries
     	alto_purge_db(ALTO_DB_req);
-...
     	//ALTO_XML_req = alto_create_request_XML(ALTO_DB_req, rc_host, pri_rat, sec_rat);
     	// *** start async query thread ***
     	threadArgs.list = list;
     	threadArgs.num = num;
     	pthread_attr_init(&attr);
-...
     	if (pthread_create(&threadId, &attr, alto_query_thread_func, &threadArgs) != 0) {
     		fprintf(stderr,"[ALTOclient] pthread_create failed!\n");
     		queryState = ALTO_QUERY_READY;
     		return ALTO_QUERY_EXEC_THREAD_FAIL;
     		return 0;
+    	}
     	// This should be it
     	return res;
     	return 1;
+    }
     /*
      * Function:	With this call the internal request to update the DB is triggered.
      * 				This should be done on a regual basis to keep the local ALTO-DB
      * 				up2date
      */
     void do_ALTO_update(struct in_addr rc_host, int pri_rat, int sec_rat){
     	if (!ALTO_DB_req) {
     		errorMsg("ALTO_DB_req is NULL!");
     		return;
+    	}
     	assertCheck(ALTO_DB_req, "ALTO_DB_req is NULL!");
     	// Step 2: create an XML from the DB entries
     	ALTO_XML_req = alto_create_request_XML(ALTO_DB_req, rc_host, pri_rat, sec_rat);
     	if (!ALTO_XML_req) {
     		errorMsg("alto_create_request_XML failed!");
     		return;
+    	}
     #ifndef USE_LOCAL_REPLY_XML
     	// Step2a: send POST request to ALTO server
-...
     		xmlFreeDoc(ALTO_XML_res);
     		ALTO_XML_res = NULL;
     	} else {
     		alto_debugf("** WARNING: Invalid response from ALTO server! (%s)\n", __FUNCTION__);
+    	}
     	// free xml data

     #define ALTO_QUERY_READY		0
     #define ALTO_QUERY_INPROGRESS	1
     /** Maximum server response time in seconds */
     #define ALTO_TIMEOUT	20
     /**
      * Return codes of ALTO_query_exec.
      * ALTO_QUERY_EXEC_TIMEOUT means the last query timed out, but the new query started fine.
      */
     #define ALTO_QUERY_EXEC_OK			0
     #define ALTO_QUERY_EXEC_INPROGRESS	1
     #define ALTO_QUERY_EXEC_THREAD_FAIL	2
     #define ALTO_QUERY_EXEC_TIMEOUT		3
     /** statistics IDs for ALTO_stats */
     #define ALTO_STAT_FAILURE_COUNT			0
     #define ALTO_STAT_FAILURE_COUNT_TOTAL	1
     /**
      * This is the struct of one element for the internal interface. Make lists out of it to interact with the client.
      */
-...
     int get_ALTO_guidance_for_list(ALTO_GUIDANCE_T * list, int num, struct in_addr rc_host, int pri_rat, int sec_rat);
     /**
      *	Asynchronous/threaded ALTO query. Return codes are ALTO_QUERY_EXEC_* (see defines above).
      *  ALTO_QUERY_EXEC_TIMEOUT means last query timed out, but the new query started fine.
      *	Asynchronous/threaded ALTO query.
      *	@see get_ALTO_guidance_for_list
      */
     int ALTO_query_exec(ALTO_GUIDANCE_T * list, int num, struct in_addr rc_host, int pri_rat, int sec_rat);
-...
      */
     int ALTO_query_state();
     /**
      *  Returns statistics value for the given ALTO_STAT_* ID.
      *  @return requested statistics value.
      */
     int ALTO_stats(int stats_id);
     #endif /* ALTOCLIENT_H */

     LDFLAGS += -L$(XMLLIB)
     LDLIBS += -lxml2 -lpthread
     ifdef CURL
     LDLIBS += -lcurl
     CPPFLAGS += -DUSE_CURL
     endif
     # libcurl is now obsolete
     #LDLIBS += -lcurl
     all: main lib

Makefile.am
1	1	AUTOMAKE_OPTIONS = foreign no-dist no-installinfo
2	2	ACLOCAL_AMFLAGS = -I m4
3		SUBDIRS = . common dclog rep monl
	3	SUBDIRS = . common dclog ml rep monl tests ALTOclient
4	4
5	5	#include aminclude.am
6	6

     AC_PROG_RANLIB
     AC_LANG_C
     AC_CHECK_HEADER(netdb.h)
     if test "$ac_cv_header_netdb_h" == no
     then
     	AC_MSG_ERROR([netdb.h is missing, unable to continue])
     	exit -1
     fi
     if test "$ac_cv_header_sys_types_h" == no
     then

     #include <sys/stat.h>
     #include <errno.h>
     #include <fcntl.h>
     //#include <netdb.h>
     #include <netdb.h>
     #include <stdarg.h>
     #include <stdio.h>
     #include <stdlib.h>
-...
     #ifndef WIN32
     #include <sys/socket.h>
     #include <netinet/in.h>
     #else
     static struct tm *localtime_r(const time_t *clock, struct tm *result) {
         struct tm *res = localtime(clock);
         *result = *res;
       return result;
+    }
     #endif
     // dclog headers
-...
       // If the user-specified level is higher than the logging level for
       // this DCLog object, return success
       if (lev > dclog->lev) {
       if (lev > dclog->lev)
         return 1;
+      }
       // If we are using the unique filename by day of the month feature,
       // DCLOG_FEAT_UNIQUE, see if the day of the month has changed

             DCLogSetHeader( dclog, 1 );
             DCLogSetPrintLevel( dclog, 1 );
     #if !WIN32 && !MAC_OS
     	logstream = open_memstream(&logbuffer, &logbuffer_size);
     	if (!logstream) {
     		fprintf(stderr, "Unable to initialize logger, exiting");
     		exit(-1);
+    	}
     #else
             logbuffer_size=1000;
     	logbuffer = (char *) malloc(logbuffer_size);
     #endif
             initialized = 1;
+    }
-...
     	if (!initialized) return;
     	rewind(logstream);
       	va_start( str_args, fmt );
     #if !WIN32 && !MAC_OS
     	rewind(logstream);
       	if (vfprintf( logstream, fmt, str_args ) < 0) return;
       	va_end( str_args );
     	char zero = 0;
     	if (fwrite(&zero, 1, 1, logstream) != 1) return;
     	fflush(logstream);
     #else
             if (vsnprintf( logbuffer, logbuffer_size, fmt, str_args) < 0) return;
             logbuffer[logbuffer_size - 1] = '\0';
     #endif
       	va_end( str_args );
     //fprintf(stderr, "X.do logger lev:%d, msg %s\n", lev, logbuffer);
     	DCLogWrite(dclog, lev , logbuffer);
             fflush(dclog->fp);
+    }

     #define ALTO_QUERY_READY		0
     #define ALTO_QUERY_INPROGRESS	1
     /** Maximum server response time in seconds */
     #define ALTO_TIMEOUT	20
     /**
      * Return codes of ALTO_query_exec.
      * ALTO_QUERY_EXEC_TIMEOUT means the last query timed out, but the new query started fine.
      */
     #define ALTO_QUERY_EXEC_OK			0
     #define ALTO_QUERY_EXEC_INPROGRESS	1
     #define ALTO_QUERY_EXEC_THREAD_FAIL	2
     #define ALTO_QUERY_EXEC_TIMEOUT		3
     /** statistics IDs for ALTO_stats */
     #define ALTO_STAT_FAILURE_COUNT			0
     #define ALTO_STAT_FAILURE_COUNT_TOTAL	1
     /**
      * This is the struct of one element for the internal interface. Make lists out of it to interact with the client.
      */
-...
     int get_ALTO_guidance_for_list(ALTO_GUIDANCE_T * list, int num, struct in_addr rc_host, int pri_rat, int sec_rat);
     /**
      *	Asynchronous/threaded ALTO query. Return codes are ALTO_QUERY_EXEC_* (see defines above).
      *  ALTO_QUERY_EXEC_TIMEOUT means last query timed out, but the new query started fine.
      *	Asynchronous/threaded ALTO query.
      *	@see get_ALTO_guidance_for_list
      */
     int ALTO_query_exec(ALTO_GUIDANCE_T * list, int num, struct in_addr rc_host, int pri_rat, int sec_rat);
-...
      */
     int ALTO_query_state();
     /**
      *  Returns statistics value for the given ALTO_STAT_* ID.
      *  @return requested statistics value.
      */
     int ALTO_stats(int stats_id);
     #endif /* ALTOCLIENT_H */

     #include <sys/types.h>
     #include <stdbool.h>
     #include <stdlib.h>
     #ifdef WIN32
     #include <winsock2.h>
     #endif
     #ifndef byte
     /** 8-bit unsigned type */

     /* a remote error occured while activating the measure */
     RFAILED,
     /* you called monActivateMeasure with wrong paramters */
     MS_ERROR,
     ERROR,
     /* the measure is beeing set up */
     INITIALISING,
     /* the measure is beeing stopped */

     INCLUDES = -I$(top_srcdir)/include/  #-I$(top_srcdir)/dclog
     noinst_LIBRARIES = libml.a
     libml_a_SOURCES = BUGS.txt ml.c ml_log.c util/stun.c \
     	util/udpSocket.c util/rateLimiter.c util/queueManagement.c
     libml_a_SOURCES = BUGS.txt ml.c util/stun.c \
     	util/udpSocket.c util/rateControl.c
     # transmissionHandler.c
     # testMessaginglayer: echoServer.c ml.h ml.c transmissionHandler.h transmissionHandler.c util/stun.h util/stun.c util/udpSocket.h util/udpSocket.c
     #        ${COMPILER} -o echoServer.o echoServer.c ml.h ml.c transmissionHandler.h transmissionHandler.c util/stun.h util/stun.c util/udpSocket.h util/udpSocket.c ${EVENT} ${MATH} ${GDB}
     #        ${COMPILER} -o echoServer.o echoServer.c ml.h ml.c transmissionHandler.h transmissionHandler.c util/stun.h util/stun.c util/udpSocket.h util/udpSocket.c util/rateControl.c ${EVENT} ${MATH} ${GDB}
     #libml_a_LIBADD = $(top_builddir)/dclog/libdclog.a

     #include <stdint.h>
     #include <sys/time.h>
     /**
      * @brief The size of a socketID
      */
-...
     int mlInit(bool recv_data_cb,struct timeval timeout_value,const int port,const char *ipaddr,const int stun_port,const char *stun_ipaddr,receive_localsocketID_cb local_socketID_cb,void *arg);
     /**
       * Configure the verbosity of messages
       * @param log_level [0-4] the lower the less messages are printed out
       * Configure the parameters for output rate control.
       * These values may also be set while packets are being transmitted.
       * @param bucketsize The size of the bucket in kbytes
       * @param drainrate The amount of kbytes draining in a second. If drainrate is <=0, then rateControl is completely disabled (all packets are passed).
     */
     void mlSetVerbosity(int log_level);
     void mlSetThrottle(int bucketsize, int drainrate);
     /**
      * @brief Register a received packet callback.
-...
      */
     int mlGetPathMTU(int ConnectionId);
     /**
       * Configure the parameters for output rate control.
       * @param bucketsize The size of the bucket in kbytes
       * @param drainrate The amount of kbytes draining in a second. If drainrate is <=0, then rateControl is completely disabled (all packets are passed).
       * @param maxQueueSize In kbytes. Max data stored while limiting the output rate. If 0 packets limitted by drainrate are dropped.
       * @param maxQueueSizeRTX In kbytes. Max data waiting for the retransmission if needed.
       * @param maxTimeToHold. Time for which sent packets are stored in RTX queue in seconds.
     */
     void mlSetRateLimiterParams(int bucketsize, int drainrate, int maxQueueSize, int maxQueueSizeRTX, double maxTimeToHold);
     #ifdef __cplusplus
+    }
     #endif

      *     THIS HEADER MAY NOT BE EXTRACTED OR MODIFIED IN ANY WAY.
      */
     #include <arpa/inet.h>
     #ifndef WIN32
     #include <netinet/in.h>
     #include <sys/socket.h>
     #endif
     #include <fcntl.h>
     #include <event2/event.h>
     #include <stdlib.h>
     #include <unistd.h>
     #include <stdio.h>
-...
     #include <stdint.h>
     #include <string.h>
     #include <sys/types.h>
     #include <arpa/inet.h>
     #include <netdb.h>
     #include <errno.h>
     #include <time.h>
     #include <math.h>
     #include <assert.h>
     #include <errno.h>
     #ifndef WIN32
     #include <arpa/inet.h>
     #include <netdb.h>
     #include <netinet/in.h>
     #include <sys/socket.h>
     #include <fcntl.h>
     #else
     #include <winsock2.h>
     #include <ws2tcpip.h>
     #endif
     #include "util/udpSocket.h"
     #include "util/stun.h"
     #include "transmissionHandler.h"
     #include "util/rateLimiter.h"
     #include "util/queueManagement.h"
     #define LOG_MODULE "[ml] "
     #include "ml_log.h"
-...
      */
     #define RECV_TIMEOUT_DEFAULT { 2, 0 }
     #ifdef RTX
     /*
      * default timeout value for a packet reception
      */
     #define PKT_RECV_TIMEOUT_DEFAULT { 0, 50000 } // 50 ms
     /*
      * default timeout value for a packet reception
      */
     #define LAST_PKT_RECV_TIMEOUT_DEFAULT { 1, 700000 }
     /*
      * default fraction of RECV_TIMEOUT_DEFAULT for a last packet(s) reception timeout
      */
     #define LAST_PKT_RECV_TIMEOUT_FRACTION 0.7
     #endif
     /*
      * global variables
      */
     /*
      * define a buffer of pointers to connect structures
      */
-...
     /*
      * helper function to get rid of a warning
      */
     #ifndef WIN32
     int min(int a, int b) {
     	if (a > b) return b;
     	return a;
+    }
     #endif
     #ifdef RTX
     //*********Counters**********
     struct Counters {
     	unsigned int receivedCompleteMsgCounter;
     	unsigned int receivedIncompleteMsgCounter;
     	unsigned int receivedDataPktCounter;
     	unsigned int receivedRTXDataPktCounter;
     	unsigned int receivedNACK1PktCounter;
     	unsigned int receivedNACKMorePktCounter;
     	unsigned int sentDataPktCounter;
     	unsigned int sentRTXDataPktCtr;
     	unsigned int sentNACK1PktCounter;
     	unsigned int sentNACKMorePktCounter;
     } counters;
     extern unsigned int sentRTXDataPktCounter;
     /*
      * receive timeout for a packet
      */
     static struct timeval pkt_recv_timeout = PKT_RECV_TIMEOUT_DEFAULT;
     static struct timeval last_pkt_recv_timeout = LAST_PKT_RECV_TIMEOUT_DEFAULT;
     void mlShowCounters() {
     	counters.sentRTXDataPktCtr = sentRTXDataPktCounter;
     	fprintf(stderr, "\nreceivedCompleteMsgCounter: %d\nreceivedIncompleteMsgCounter: %d\nreceivedDataPktCounter: %d\nreceivedRTXDataPktCounter: %d\nreceivedNACK1PktCounter: %d\nreceivedNACKMorePktCounter: %d\nsentDataPktCounter: %d\nsentRTXDataPktCtr: %d\nsentNACK1PktCounter: %d\nsentNACKMorePktCounter: %d\n", counters.receivedCompleteMsgCounter, counters.receivedIncompleteMsgCounter, counters.receivedDataPktCounter, counters.receivedRTXDataPktCounter, counters.receivedNACK1PktCounter, counters.receivedNACKMorePktCounter, counters.sentDataPktCounter, counters.sentRTXDataPktCtr, counters.sentNACK1PktCounter, counters.sentNACKMorePktCounter);
     	return;
+    }
     void recv_nack_msg(struct msg_header *msg_h, char *msgbuf, int msg_size)
+    {
     	struct nack_msg *nackmsg;
     	msgbuf += msg_h->len_mon_data_hdr;
     	msg_size -= msg_h->len_mon_data_hdr;
     	nackmsg = (struct nack_msg*) msgbuf;
     	unsigned int gapSize = nackmsg->offsetTo - nackmsg->offsetFrom;
     	//if (gapSize == 1349) counters.receivedNACK1PktCounter++;
     	//else counters.receivedNACKMorePktCounter++;
     	rtxPacketsFromTo(nackmsg->con_id, nackmsg->msg_seq_num, nackmsg->offsetFrom, nackmsg->offsetTo);
+    }
     void pkt_recv_timeout_cb(int fd, short event, void *arg){
     	int recv_id = (long) arg;
     	debug("ML: recv_timeout_cb called. Timeout for id:%d\n",recv_id);
     	//check if message still exists
     	if (recvdatabuf[recv_id] == NULL) return;
     	//check if gap was filled in the meantime
     	if (recvdatabuf[recv_id]->gapArray[recvdatabuf[recv_id]->firstGap].offsetFrom == recvdatabuf[recv_id]->gapArray[recvdatabuf[recv_id]->firstGap].offsetTo) {
     		recvdatabuf[recv_id]->firstGap++;
     		return;
+    	}
     	struct nack_msg nackmsg;
     	nackmsg.con_id = recvdatabuf[recv_id]->txConnectionID;
     	nackmsg.msg_seq_num = recvdatabuf[recv_id]->seqnr;
     	nackmsg.offsetFrom = recvdatabuf[recv_id]->gapArray[recvdatabuf[recv_id]->firstGap].offsetFrom;
     	nackmsg.offsetTo = recvdatabuf[recv_id]->gapArray[recvdatabuf[recv_id]->firstGap].offsetTo;
     	recvdatabuf[recv_id]->firstGap++;
     	unsigned int gapSize = nackmsg.offsetTo - nackmsg.offsetFrom;
     	//if (gapSize == 1349) counters.sentNACK1PktCounter++;
     	//else counters.sentNACKMorePktCounter++;
     	//fprintf(stderr,"Sending NACK <- msg_seq_num: %d. monitoringDataHeaderLen: %d. offsetFrom: %d offsetTo: %d \n", nackmsg.msg_seq_num, recvdatabuf[recv_id]->monitoringDataHeaderLen, nackmsg.offsetFrom, nackmsg.offsetTo);
     	send_msg(recvdatabuf[recv_id]->connectionID, ML_NACK_MSG, (char *) &nackmsg, sizeof(struct nack_msg), true, &(connectbuf[recvdatabuf[recv_id]->connectionID]->defaultSendParams));
+    }
     void last_pkt_recv_timeout_cb(int fd, short event, void *arg){
     	int recv_id = (long) arg;
     	debug("ML: recv_timeout_cb called. Timeout for id:%d\n",recv_id);
     	if (recvdatabuf[recv_id] == NULL) {
     		//fprintf(stderr,"Called last_pkt_recv_timeout_cb but there is no slot\n");
     		return;
+    	}
     	//fprintf(stderr,"Starting last_pkt_recv_timeout_cb for msg_seq_num: %d\n", recvdatabuf[recv_id]->seqnr);
     	if (recvdatabuf[recv_id]->expectedOffset == recvdatabuf[recv_id]->bufsize - recvdatabuf[recv_id]->monitoringDataHeaderLen) return;
     	struct nack_msg nackmsg;
     	nackmsg.con_id = recvdatabuf[recv_id]->txConnectionID;
     	nackmsg.msg_seq_num = recvdatabuf[recv_id]->seqnr;
     	nackmsg.offsetFrom = recvdatabuf[recv_id]->expectedOffset;
     	nackmsg.offsetTo = recvdatabuf[recv_id]->bufsize - recvdatabuf[recv_id]->monitoringDataHeaderLen;
     	unsigned int gapSize = nackmsg.offsetTo - nackmsg.offsetFrom;
     	//if (gapSize == 1349) counters.sentNACK1PktCounter++;
     	//else counters.sentNACKMorePktCounter++;
     	//fprintf(stderr,"last_pkt - Sending NACK <- msg_seq_num: %d. monitoringDataHeaderLen: %d. offsetFrom: %d offsetTo: %d \n", nackmsg.msg_seq_num, recvdatabuf[recv_id]->monitoringDataHeaderLen, nackmsg.offsetFrom, nackmsg.offsetTo);
     	send_msg(recvdatabuf[recv_id]->connectionID, ML_NACK_MSG, &nackmsg, sizeof(struct nack_msg), true, &(connectbuf[recvdatabuf[recv_id]->connectionID]->defaultSendParams));
+    }
     #endif
     /*
      * convert a socketID to a string. It uses a static buffer, so either strdup is needed, or the string will get lost!
-...
     			msg_h.offset = htonl(offset);
     			msg_h.msg_length = htonl(truncable ? pkt_len : msg_len);
     			//monitoring layer hook
     			if(get_Send_pkt_inf_cb != NULL && iov[1].iov_len) {
     				mon_pkt_inf pkt_info;
     				memset(h_pkt,0,MON_PKT_HEADER_SPACE);
     				pkt_info.remote_socketID = &(connectbuf[con_id]->external_socketID);
     				pkt_info.buffer = msg + offset;
     				pkt_info.bufSize = pkt_len;
     				pkt_info.msgtype = msg_type;
     				pkt_info.dataID = connectbuf[con_id]->seqnr;
     				pkt_info.offset = offset;
     				pkt_info.datasize = msg_len;
     				pkt_info.monitoringHeaderLen = iov[1].iov_len;
     				pkt_info.monitoringHeader = iov[1].iov_base;
     				pkt_info.ttl = -1;
     				memset(&(pkt_info.arrival_time),0,sizeof(struct timeval));
     				(get_Send_pkt_inf_cb) ((void *) &pkt_info);
+    			}
     			debug("ML: sending packet to %s with rconID:%d lconID:%d\n", conid_to_string(con_id), ntohl(msg_h.remote_con_id), ntohl(msg_h.local_con_id));
     			int priority = 0;
     			if ((msg_type == ML_CON_MSG)
     #ifdef RTX
      || (msg_type == ML_NACK_MSG)
     #endif
     ) priority = HP;
     			//fprintf(stderr,"*******************************ML.C: Sending packet: msg_h.offset: %d msg_h.msg_seq_num: %d\n",ntohl(msg_h.offset),ntohl(msg_h.msg_seq_num));
     			switch(queueOrSendPacket(socketfd, iov, 4, &udpgen.udpaddr,priority)) {
     			switch(sendPacket(socketfd, iov, 4, &udpgen.udpaddr)) {
     				case MSGLEN:
     					info("ML: sending message failed, reducing MTU from %d to %d (to:%s conID:%d lconID:%d msgsize:%d offset:%d)\n", connectbuf[con_id]->pmtusize, pmtu_decrement(connectbuf[con_id]->pmtusize), conid_to_string(con_id), ntohl(msg_h.remote_con_id), ntohl(msg_h.local_con_id), msg_len, offset);
     					// TODO: pmtu decremented here, but not in the "truncable" packet. That is currently resent without changing the claimed pmtu. Might need to be changed.
-...
     					offset = msg_len; // exit the while
     					break;
     				case OK:
     #ifdef RTX
     					if (msg_type < 127) counters.sentDataPktCounter++;
     #endif
     					//update
     					offset += pkt_len;
     					//transmit data header only in the first packet
-...
+    			}
     		} while(offset != msg_len && !truncable);
     	} while(retry);
     	//fprintf(stderr, "sentDataPktCounter after msg_seq_num = %d: %d\n", msg_h.msg_seq_num, counters.sentDataPktCounter);
     	//fprintf(stderr, "sentRTXDataPktCounter after msg_seq_num = %d: %d\n", msg_h.msg_seq_num, counters.sentRTXDataPktCtr);
+    }
     void pmtu_timeout_cb(int fd, short event, void *arg);
     int sendPacket(const int udpSocket, struct iovec *iov, int len, struct sockaddr_in *socketaddr) {
     	//monitoring layer hook
     	if(get_Send_pkt_inf_cb != NULL && iov[1].iov_len) {
     		mon_pkt_inf pkt_info;
     		struct msg_header *msg_h  = (struct msg_header *) iov[0].iov_base;
     		memset(iov[1].iov_base,0,iov[1].iov_len);
     		pkt_info.remote_socketID = &(connectbuf[ntohl(msg_h->local_con_id)]->external_socketID);
     		pkt_info.buffer = iov[3].iov_base;
     		pkt_info.bufSize = iov[3].iov_len;
     		pkt_info.msgtype = msg_h->msg_type;
     		pkt_info.dataID = ntohl(msg_h->msg_seq_num);
     		pkt_info.offset = ntohl(msg_h->offset);
     		pkt_info.datasize = ntohl(msg_h->msg_length);
     		pkt_info.monitoringHeaderLen = iov[1].iov_len;
     		pkt_info.monitoringHeader = iov[1].iov_base;
     		pkt_info.ttl = -1;
     		memset(&(pkt_info.arrival_time),0,sizeof(struct timeval));
     		(get_Send_pkt_inf_cb) ((void *) &pkt_info);
+    	}
      	//struct msg_header *msg_h;
         //msg_h = (struct msg_header *) iov[0].iov_base;
     	//fprintf(stderr,"*** Sending packet - msgSeqNum: %d offset: %d\n",ntohl(msg_h->msg_seq_num),ntohl(msg_h->offset));
     	return sendPacketFinal(udpSocket, iov, len, socketaddr);
+    }
     void reschedule_conn_msg(int con_id)
+    {
     	if (connectbuf[con_id]->timeout_event) {
-...
     	msg_header->pmtu_size = connectbuf[con_id]->pmtusize;
     	memcpy(&(msg_header->sock_id), loc_socketID, sizeof(socket_ID));
+      {
                             char buf[SOCKETID_STRING_SIZE];
                             mlSocketIDToString(&((struct conn_msg*)connectbuf[con_id]->ctrl_msg_buf)->sock_id,buf,sizeof(buf));
                             debug("Local socket_address sent in INVITE: %s, sizeof msg %ld\n", buf, sizeof(struct conn_msg));
+       }
     	send_msg(con_id, ML_CON_MSG, connectbuf[con_id]->ctrl_msg_buf, buf_size, true, &(connectbuf[con_id]->defaultSendParams));
+    }
-...
     				connectbuf[free_con_id]->connection_head = connectbuf[free_con_id]->connection_last = NULL;
     				connectbuf[free_con_id]->starttime = time(NULL);
     				memcpy(&(connectbuf[free_con_id]->external_socketID), &(con_msg->sock_id), sizeof(socket_ID));
     		//Workaround to support reuse of socketID
     				connectbuf[free_con_id]->external_socketID.internal_addr.udpaddr.sin_family=AF_INET;
     				connectbuf[free_con_id]->external_socketID.external_addr.udpaddr.sin_family=AF_INET;
     				connectbuf[free_con_id]->pmtusize = con_msg->pmtu_size;	// bootstrap pmtu from the other's size. Not strictly needed, but a good hint
     				connectbuf[free_con_id]->timeout_event = NULL;
     				connectbuf[free_con_id]->external_connectionID = msg_h->local_con_id;
-...
     		NAT_traversal = true;
     		// callback to the upper layer indicating that the socketID is now
     		// ready to use
+    		{
                     	char buf[SOCKETID_STRING_SIZE];
                     	mlSocketIDToString(&local_socketID,buf,sizeof(buf));
      			debug("received local socket_address: %s\n", buf);
+    		}
     		(receive_SocketID_cb) (&local_socketID, 0);
+    	}
+    }
-...
     			&(connectbuf[recvdatabuf[recv_id]->connectionID]->external_socketID);
     		rParams.firstPacketArrived = recvdatabuf[recv_id]->firstPacketArrived;
     #ifdef RTX
     		counters.receivedIncompleteMsgCounter++;
     		//mlShowCounters();
     		//fprintf(stderr,"******Cleaning slot for inclomplete msg_seq_num: %d\n", recvdatabuf[recv_id]->seqnr);
     #endif
      		//(receive_data_callback) (recvdatabuf[recv_id]->recvbuf + recvdatabuf[recv_id]->monitoringDataHeaderLen, recvdatabuf[recv_id]->bufsize - recvdatabuf[recv_id]->monitoringDataHeaderLen, recvdatabuf[recv_id]->msgtype, &rParams);
     // 		(receive_data_callback) (recvdatabuf[recv_id]->recvbuf + recvdatabuf[recv_id]->monitoringDataHeaderLen, recvdatabuf[recv_id]->bufsize - recvdatabuf[recv_id]->monitoringDataHeaderLen,
     // 			recvdatabuf[recv_id]->msgtype, &rParams);
     		//clean up
     		if (recvdatabuf[recv_id]->timeout_event) {
-...
     		return;
+    	}
     #ifdef RTX
     	counters.receivedDataPktCounter++;
     #endif
     	// check if a recv_data exist and enter data
     	for (recv_id = 0; recv_id < RECVDATABUFSIZE; recv_id++)
     		if (recvdatabuf[recv_id] != NULL) {
-...
     		recvdatabuf[recv_id]->bufsize = msg_h->msg_length + msg_h->len_mon_data_hdr;
     		recvdatabuf[recv_id]->recvbuf = (char *) malloc(recvdatabuf[recv_id]->bufsize);
     		recvdatabuf[recv_id]->arrivedBytes = 0;	//count this without the Mon headers
     #ifdef RTX
     		recvdatabuf[recv_id]->txConnectionID = msg_h->local_con_id;
     		recvdatabuf[recv_id]->expectedOffset = 0;
     		recvdatabuf[recv_id]->gapCounter = 0;
     		recvdatabuf[recv_id]->firstGap = 0;
     		recvdatabuf[recv_id]->last_pkt_timeout_event = NULL;
     #endif
     		/*
     		* read the timeout data and set it
     		*/
-...
     	//if first packet extract mon data header and advance pointer
     	if (msg_h->offset == 0) {
     		//fprintf(stderr,"Hoooooray!! We have first packet of some message!!\n");
     		memcpy(recvdatabuf[recv_id]->recvbuf, msgbuf, msg_h->len_mon_data_hdr);
     		msgbuf += msg_h->len_mon_data_hdr;
     		bufsize -= msg_h->len_mon_data_hdr;
-...
     	// increment fragmentnr
     	recvdatabuf[recv_id]->recvFragments++;
     	// increment the arrivedBytes
     	recvdatabuf[recv_id]->arrivedBytes += bufsize;
     	//fprintf(stderr,"Arrived bytes: %d Offset: %d Expected offset: %d\n",recvdatabuf[recv_id]->arrivedBytes/1349,msg_h->offset/1349,recvdatabuf[recv_id]->expectedOffset/1349);
     	recvdatabuf[recv_id]->arrivedBytes += bufsize;
     	// enter the data into the buffer
     	memcpy(recvdatabuf[recv_id]->recvbuf + msg_h->len_mon_data_hdr + msg_h->offset, msgbuf, bufsize);
     #ifdef RTX
     	// detecting a new gap
     	if (msg_h->offset > recvdatabuf[recv_id]->expectedOffset) {
     		recvdatabuf[recv_id]->gapArray[recvdatabuf[recv_id]->gapCounter].offsetFrom = recvdatabuf[recv_id]->expectedOffset;
     		recvdatabuf[recv_id]->gapArray[recvdatabuf[recv_id]->gapCounter].offsetTo = msg_h->offset;
     		if (recvdatabuf[recv_id]->gapCounter < RTX_MAX_GAPS - 1) recvdatabuf[recv_id]->gapCounter++;
     		evtimer_add(event_new(base, -1, EV_TIMEOUT, &pkt_recv_timeout_cb, (void *) (long)recv_id), &pkt_recv_timeout);
+    	}
     	//filling the gap by delayed packets
     	if (msg_h->offset < recvdatabuf[recv_id]->expectedOffset){
     		counters.receivedRTXDataPktCounter++;
     		//skip retransmitted packets
     		if (recvdatabuf[recv_id]->firstGap < recvdatabuf[recv_id]->gapCounter && msg_h->offset >= recvdatabuf[recv_id]->gapArray[recvdatabuf[recv_id]->firstGap].offsetFrom) {
     			int i;
     			//fprintf(stderr,"firstGap: %d	gapCounter: %d\n", recvdatabuf[recv_id]->firstGap, recvdatabuf[recv_id]->gapCounter);
     			for (i = recvdatabuf[recv_id]->firstGap; i < recvdatabuf[recv_id]->gapCounter; i++){
     				if (msg_h->offset == recvdatabuf[recv_id]->gapArray[i].offsetFrom) {
     					recvdatabuf[recv_id]->gapArray[i].offsetFrom += bufsize;
     					break;
+    				}
     				if (msg_h->offset == (recvdatabuf[recv_id]->gapArray[i].offsetTo - bufsize)) {
     					recvdatabuf[recv_id]->gapArray[i].offsetTo -= bufsize;
     					break;
+    				}
+    			}
     		} else {//fprintf(stderr,"Skipping retransmitted packets in filling the gap.\n");
     			//counters.receivedRTXDataPktCounter++;
+    			}
+    	}
     	//updating the expectedOffset
     	if (msg_h->offset >= recvdatabuf[recv_id]->expectedOffset) recvdatabuf[recv_id]->expectedOffset = msg_h->offset + bufsize;
     #endif
     	//TODO very basic checkif all fragments arrived: has to be reviewed
     	if(recvdatabuf[recv_id]->arrivedBytes == recvdatabuf[recv_id]->bufsize - recvdatabuf[recv_id]->monitoringDataHeaderLen)
-...
     				debug("ML: received message from conID:%d, %s\n",recvdatabuf[recv_id]->connectionID,str);
     				rParams.firstPacketArrived = recvdatabuf[recv_id]->firstPacketArrived;
     #ifdef RTX
     				counters.receivedCompleteMsgCounter++;
     				//mlShowCounters();
     #endif
     				(receive_data_callback) (recvdatabuf[recv_id]->recvbuf + recvdatabuf[recv_id]->monitoringDataHeaderLen, recvdatabuf[recv_id]->bufsize - recvdatabuf[recv_id]->monitoringDataHeaderLen,
     					recvdatabuf[recv_id]->msgtype, (void *) &rParams);
     			} else {
     			    warn("ML: callback not initialized for this message type: %d!\n",msg_h->msg_type);
+    			}
     			//clean up
     			if (recvdatabuf[recv_id]->timeout_event) {
     				debug("ML: freeing timeout for %d\n",recv_id);
     				debug("ML: freeing timeout for %d",recv_id);
     				event_del(recvdatabuf[recv_id]->timeout_event);
     				event_free(recvdatabuf[recv_id]->timeout_event);
     				recvdatabuf[recv_id]->timeout_event = NULL;
     			} else {
     				debug("ML: received in 1 packet\n",recv_id);
+    			}
     #ifdef RTX
     			if (recvdatabuf[recv_id]->last_pkt_timeout_event) {
     				debug("ML: freeing last packet timeout for %d",recv_id);
     				event_del(recvdatabuf[recv_id]->last_pkt_timeout_event);
     				event_free(recvdatabuf[recv_id]->last_pkt_timeout_event);
     				recvdatabuf[recv_id]->last_pkt_timeout_event = NULL;
+    			}
     			//fprintf(stderr,"******Cleaning slot for clomplete msg_seq_num: %d\n", recvdatabuf[recv_id]->seqnr);
     #endif
     			free(recvdatabuf[recv_id]->recvbuf);
     			free(recvdatabuf[recv_id]);
     			recvdatabuf[recv_id] = NULL;
-...
     				//TODO make timeout at least a DEFINE
     				recvdatabuf[recv_id]->timeout_event = event_new(base, -1, EV_TIMEOUT, &recv_timeout_cb, (void *) (long)recv_id);
     				evtimer_add(recvdatabuf[recv_id]->timeout_event, &recv_timeout);
     #ifdef RTX
     				recvdatabuf[recv_id]->last_pkt_timeout_event = event_new(base, -1, EV_TIMEOUT, &last_pkt_recv_timeout_cb, (void *) (long)recv_id);
     				evtimer_add(recvdatabuf[recv_id]->last_pkt_timeout_event, &last_pkt_recv_timeout);
     #endif
+    			}
+    		}
+    	}
-...
+    	}
     	//error in PMTU discovery?
     	if (connectbuf[con_id]->pmtusize == P_ERROR) {
     	if (connectbuf[con_id]->pmtusize == ERROR) {
     		if (connectbuf[con_id]->internal_connect == true) {
     			//as of now we tried directly connecting, now let's try trough the NAT
     			connectbuf[con_id]->internal_connect = false;
-...
     	case BELOWDSL:
     		return MIN;
     	case MIN:
     		return P_ERROR;
     		return ERROR;
     	default:
     		warn("ML: strange pmtu size encountered:%d, changing to some safe value:%d\n", pmtusize, MIN);
     		return MIN;
-...
     //    connectbuf[connectionID]->pmtutrysize = new_pmtusize;
         if (new_pmtusize == P_ERROR) {
         if (new_pmtusize == ERROR) {
     		error("ML:  Could not create connection with connectionID %i !\n",
     			connectionID);
-...
     	unsigned short stun_bind_response = 0x0101;
     	unsigned short * msgspot = (unsigned short *) msgbuf;
     	if (*msgspot == stun_bind_response) {
     		debug("ML: recv_pkg: parse stun message called on %d bytes\n", recvSize);
     		debug("ML: recv_pkg: parse stun message called\n");
     		recv_stun_msg(msgbuf, recvSize);
     		return;
+    	}
-...
     			debug("ML: received conn pkg\n");
     			recv_conn_msg(msg_h, bufptr, msg_size, &recv_addr);
     			break;
     #ifdef RTX
     		case ML_NACK_MSG:
     			debug("ML: received nack pkg\n");
     			recv_nack_msg(msg_h, bufptr, msg_size);

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff