static mx_xscore_size_t _score2xscore(mx_real_t score, mx_stype_t type)
	{
	mx_xscore_size_t xs;

	/* first check parameters ... */
	if (!score)
		return(-1);
	if (!_stype_isvalid(type))
		rs_error("can't convert score of invalid type %d!",
			type);

	switch (type) {
		case mx_stype_Probability:
			xs = score * 10000.0;
			break;
		case mx_stype_LogProbability:
			xs = ((score < 650) ? (score) * 100.0 : 65535);
			break;
		default:
			rs_error("can't convert %s-type scores to external format!",
				mx_stype_text[type]);
		}

	return(xs);
	}

float lsFloat_setIndex(lsFloat_t *il, int index, float i, float i0)
{
  float ret;
  int j;

  if (!il)
    rs_error("lsFloat_setIndex: got NULL-pointer list");
  if (index < 0)
    rs_error("lsFloat_setIndex: illegal index %d",index);

  if (index >= il->max_list) {
    int d = (index - il->max_list) / LIST_BUF + 1;
    il->list = rs_realloc(il->list,
			  (il->max_list+= d*LIST_BUF) * sizeof(float), 
			  "list items");
  }
  for (j=il->n_list; j <= index; j++) 
    il->list[j] = i0;

  ret = il->list[index];

  il->list[index] = i;
  if (il->n_list <= index)
    il->n_list = index+1;

  return (ret);
}

lsBuffer_t *lsBuffer_init(lsBuffer_t *b, 
			  lsBuffer_Copy_t *_copy, lsBuffer_Free_t *_free)
{
  int err;

  if (!b)
    b = rs_malloc(sizeof(lsBuffer_t),"lsBuffer");

  lsPt_nil(&b->new);
  lsPt_nil(&b->orig);
  lsPt_nil(&b->copy);
  lsInt_nil(&b->status);
  b->update = 1;

  if ((err = pthread_mutex_init(&b->mutexNew, NULL)) != 0) {
    rs_error("lsBuffer_init: error initializing mutex: %d.", err);
  }
  if ((err = pthread_mutex_init(&b->mutexOrig, NULL)) != 0) {
    rs_error("lsBuffer_init: error initializing mutex: %d.", err);
  }
  if ((err = pthread_mutex_init(&b->mutexCopy, NULL)) != 0) {
    rs_error("lsBuffer_init: error initializing mutex: %d.", err);
  }
  if (!_copy || !_free)
    rs_error("lsBuffer_init: no copy or free function specified.");

  b->_copy = _copy;
  b->_free = _free;
  
  return (b);
}

static mx_real_t _xscore2score(mx_xscore_size_t xs, mx_stype_t type)
	{
	mx_real_t score;

	/* first check parameters ... */
	if (!xs)
		return(-1);
	if (!_stype_isvalid(type))
		rs_error("can't convert score of invalid type %d!",
			type);

	switch (type) {
		case mx_stype_Probability:
			score = (mx_real_t)(xs) / 10000.0;
			break;
		case mx_stype_LogProbability:
			score = (mx_real_t)(xs) / 100.0;
			break;
		default:
			rs_error("can't convert %s-type scores from external format!",
				mx_stype_text[type]);
		}

	return(score);
	}

int rs_bwrite(rs_IO *io, void *_ptr, int size, int n_elems)
	{
	char* ptr = (char*)_ptr;

	if (!ptr || !io)
		return(-1);

	switch(io->type) {
		case rs_iotype_mem:
			rs_error("binary write to memory not supported!");

			/* ACHTUNG: keine Grenzueberpruefung! */
			break;

		case rs_iotype_file:
			n_elems = _fwrite_padded(ptr, size, n_elems,
						io->base_size, io->fp);
			break;

		default:
			rs_error("IO type %d not supported by 'rs_bread()'!",
				io->type);
		}

	return(n_elems);
	}

naive_bayes_classifier_t *nB_fscan(naive_bayes_classifier_t *nB, char *filename, fx_select_t *sel) { 
	int class_ind, start, end, i;
    FILE *fp = NULL, *feature_fp = NULL;
    mx_real_t *features=NULL;
    char *line=NULL, *token;
    char *fname =NULL;
    char *class_name = (char *) rs_malloc(STRING_LENGTH*sizeof(char),"String");
    int full_feature_dim=sel?sel->n_features:nB->feature_dim;

    if (!nB)
		rs_error("classifier could not be initialised!");
     
	fp = fopen(filename,"r");
    if (fp == NULL) {
		rs_error("Cannot open file %s!",filename);
    }
    else {
		features = (mx_real_t *) rs_calloc(full_feature_dim, sizeof(mx_real_t), "feature vector");
	 
	 	while ((line= (char *) rs_line_read(fp,';'))) {
	    	fname = (char *) strtok(line,"\t ");
	     	feature_fp = fopen(fname, "r");
	     	if (feature_fp == NULL) {
		 		rs_warning("can't open '%s '!", fname);
		 		while (getchar() != '\n');
		 			continue;
	     	}
	     	line+= strlen(fname)+1;

		    if (feature_fp) {
				for (token = (char *) strtok(line," "); token != NULL; token = (char *) strtok(NULL, " ")) {
		     		if (sscanf(token,"%[^[]s",class_name) !=1 ) 
						rs_error("wrong length information for file %s!",fname);
		     		token += strlen(class_name);
		     		if (sscanf(token,"[%d..%d]",&start,&end) !=2)
			 			rs_error("wrong length information for file %s!",fname);
		     		for (i=start;i<=end;i++) {
			 			if (fread(features,sizeof(mx_real_t),full_feature_dim,feature_fp)!=full_feature_dim)
			     			rs_perror("fread stopped after %d elements in file %s -- %d", i, fname, errno);
			 			else {
							if (sel) 
							    if ( fx_select_apply(&features,sel,features)!= sel->n_features)
									rs_error("Feature selection did not succeed!");
							class_ind = cl_name2number(&(nB->mapping),class_name,nB->n_classes);
							nB=nB_update_classifier(nB,class_ind,features);
			 			}
		     		}
				}
				fclose(feature_fp);
	     	}
		}
		nB_finish_classifier(nB);
	}
    fclose(fp);
    rs_free(class_name);
    rs_free(features);
    
    return nB;
}

float lsFloat_get(lsFloat_t * il,int i)
{
  if (!il)
    rs_error("lsFloat_get: got NULL-pointer list");
  if (i < 0 || i >= il->n_list)
    rs_error("lsFloat_get: index [%d] out of range [%d..%d]",i,0,il->n_list);
  
  return (il->list[i]);
}

rs_IO *rs_fopen(char *name, char *mode)
	{
	FILE *fp;
	rs_IO *io;
	int mode_read, mode_mapped;
	void *buf;
	int buf_size;

	/* Lese-/Schreibmodus bestimmen ... */
	if (strchr(mode, 'w') || strchr(mode, 'a'))
		mode_read = 0;
	else if (strchr(mode, 'r'))
		mode_read = 1;
	else	rs_error("illegal mode '%s' for 'rs_fopen()'!", mode);

	/* ... ggf. ge-"mapped" (nur lesend) ... */
	if (strchr(mode, 'm')) {
		if (mode_read)
			mode_mapped = 1;
		else	{
			mode_mapped = 0;
			rs_warning("mapped file IO not supported for writing!");
			}
		}
	else	mode_mapped = 0;

	/* ... Spezialnamen '-' umsetzen ... */
	if (strcmp(name, "-") == 0) {
		if (mode_mapped)
			rs_error("mapped file IO not supported for stdin/out!");

		fp = (mode_read) ? stdin : stdout;
		}
	else	fp = fopen(name, (mode_read) ? "r" : "w");
	if (!fp)
		return(NULL);
	
	if (!mode_mapped) {
		io = rs_malloc(sizeof(rs_IO), "IO data");
		io->type = rs_iotype_file;
		io->base_size = RS_BINIO_BASE_SIZE_DEFAULT;
		io->fp = fp;
		}
	else	{
		fseek(fp, 0, SEEK_END);
		buf_size = ftell(fp);
		rewind(fp);

		buf = rs_malloc(buf_size, "mapped file buffer");
		fread(buf, buf_size, 1, fp);

		io = rs_mopen(buf, buf_size, "r");
		}

	return(io);
	}

/*
 * If the stream has no more data available, read some from F into
 * BUF, and let the stream use that.  On return, SEEN_EOF is true if
 * the end of file has passed into the stream.
 */
rs_result rs_infilebuf_fill(rs_job_t *job, rs_buffers_t *buf,
                            void *opaque)
{
    int                     len;
    rs_filebuf_t            *fb = (rs_filebuf_t *) opaque;
    FILE                    *f = fb->f;
        
    /* This is only allowed if either the buf has no input buffer
     * yet, or that buffer could possibly be BUF. */
    if (buf->next_in != NULL) {
        assert(buf->avail_in <= fb->buf_len);
        assert(buf->next_in >= fb->buf);
        assert(buf->next_in <= fb->buf + fb->buf_len);
    } else {
        assert(buf->avail_in == 0);
    }

    if (buf->eof_in || (buf->eof_in = feof(f))) {
        rs_trace("seen end of file on input");
        buf->eof_in = 1;
        return RS_DONE;
    }

    if (buf->avail_in)
        /* Still some data remaining.  Perhaps we should read
           anyhow? */
        return RS_DONE;
        
    len = fread(fb->buf, 1, fb->buf_len, f);
    if (len <= 0) {
        /* This will happen if file size is a multiple of input block len
         */
        if (feof(f)) {
            rs_trace("seen end of file on input");
            buf->eof_in = 1;
            return RS_DONE;
        }
        if (ferror(f)) {
            rs_error("error filling buf from file: %s",
                     strerror(errno));
            return RS_IO_ERROR;
        } else {
            rs_error("no error bit, but got %d return when trying to read",
                     len);
            return RS_IO_ERROR;
        }
    }
    buf->avail_in = len;
    buf->next_in = fb->buf;

    return RS_DONE;
}

float lsFloat_delSwap(lsFloat_t *il, int i)
{
  float x;

  if (LS_isNIL(il))
    rs_error("ls_delIndex: got empty list");
  if (!LS_EXISTS(il,i))
    rs_error("ls_delIndex: illegal index %d",i);

  x = LS_GET(il,i);
  LS_GET(il,i) = LS_LAST(il);
  LS_N(il)--;
  return (x);
}

int mx_scoreset_fread(mx_scoreset_t *scoreset, FILE *fp)
	{
	int i, j, tot_scores = 0;
	mx_scorelist_t *scorelist;
	mx_xscore_size_t n;
	mx_xscore_t xscore;

	if (!scoreset || !fp)
		return(-1);

	mx_scoreset_reset(scoreset);

	if (scoreset->n_lists > 1) {
		if (fread(&n, sizeof(n), 1, fp) != 1)
			return(0);
		if (n != scoreset->n_lists)
			rs_error("number of codebooks %d does not match"
				"external score data %d!",
				n, scoreset->n_lists);
		}

	for (i = 0; i < scoreset->n_lists; i++) {
		scorelist = scoreset->list[i];

		if (fread(&n, sizeof(n), 1, fp) != 1) {
			if (scoreset->n_lists > 1)
				rs_error("can't read # of scores!");
			else	return(0);
			}
		if (n <= 0)
			rs_error("illegal # of scores %d read!", n);

		for (j = 0; j < n; j++) {
			if (fread(&xscore, sizeof(xscore), 1, fp) != 1)
				rs_error("can't read external score!");
			if (xscore.id < 0)
				rs_error("illegal id %d external score data!",
					xscore.id);

			mx_scorelist_addscore(scorelist,
				xscore.id,
				_xscore2score(xscore.score, scorelist->type));
			}

		tot_scores += scorelist->n_scores;
		}

	return(tot_scores);
	}

naive_bayes_classifier_t *nB_fread_classifier(char *model_name) {
    int class_ind, weight_no=0, n_classes, feature_dim, i;
    FILE *model_fp;
    char *line, *token;
    naive_bayes_classifier_t *naiveBayes=NULL;
    
    model_fp = fopen(model_name,"r");
    if (!model_fp)
	rs_error("can't open file %s!",model_name);      

    line = (char *) rs_line_read(model_fp,'#');
    token = (char *) strtok(line,"\t");
    n_classes = atoi(token);
    line += strlen(token)+1;
    feature_dim = atoi((char *) strtok(line,"\t"));
    

    naiveBayes = nB_new_classifier(n_classes,feature_dim);
    
    class_ind=0;
    while ((line= (char *) rs_line_read(model_fp,'#')) && class_ind < n_classes) {
	char *name =(char *) strtok(line,"\t");
	int len=strlen(name)+1;
	naiveBayes->mapping[class_ind] = (char *) rs_malloc(len*sizeof(char),"class name");
	strcpy(naiveBayes->mapping[class_ind],name);
	line+=len;
	naiveBayes->class_probs[class_ind] = (mx_real_t) atof((char *) strtok(line,"\t"));
	
	while (weight_no < feature_dim && fscanf(model_fp, "%g\t%g", &naiveBayes->means[class_ind][weight_no], &naiveBayes->std_dev[class_ind][weight_no]) == 2) 
	    weight_no++;
	if (weight_no<feature_dim-1)
	    rs_error("problem with means or standard devs in file %s!",model_name);
	weight_no=0;
	class_ind++;
    }

    if (class_ind <n_classes-1)
	rs_error("problem with class no %d in file %s!",class_ind,model_name);

    //fprintf(stderr,"Classifying into the following classes:\n");
    //for (i=0;i<n_classes;i++)
	//fprintf(stderr,"%s ",naiveBayes->mapping[i]);
    //fprintf(stderr,"\n");
    
    naiveBayes->finished=1;
    fclose(model_fp);
    return naiveBayes;
}

/* Check that the given Rabin signature is valid. */
int rs_validate_rabin (const mpz_t sig,  /* purported signature of app */
		       int f,		 /* f value */
		       const mpz_t hash, /* MD5 hash of app */
                       const RSKey* key) /* key structure */
{
  mpz_t a, b;
  int result;

  if (!mpz_sgn(key->n)) {
    rs_error(key, NULL, "unable to validate: public key missing");
    return RS_ERR_MISSING_PUBLIC_KEY;
  }

  if (f < 0 || f > 3)
    return RS_SIGNATURE_INCORRECT;

  mpz_init(a);
  mpz_init(b);

  mpz_mul(a, sig, sig);
  mpz_mod(a, a, key->n);

  applyf(b, hash, key->n, f);

  result = mpz_cmp(a, b);

  mpz_clear(a);
  mpz_clear(b);
  return (result ? RS_SIGNATURE_INCORRECT : RS_SUCCESS);
}

mx_real_t svm_class_prob(svm_classifier_t *svm, mx_real_t *instance, int class_ind) {
    int i, svm_type=svm_get_svm_type(svm->model);
    double *prob_estimates=NULL;
    struct svm_node *x;
	mx_real_t class_prob;

    if (svm_type!=C_SVC && svm_type != NU_SVC)
	rs_error("Cannot give class probability for 1-class or regression SVM!");

    x = (struct svm_node *) rs_malloc((svm->feature_dim+1)*sizeof(struct svm_node),"Feature vector representation for svm");
    for (i=0;i<svm->feature_dim;i++) {
		x[i].index=i+1;
		x[i].value=instance[i];
    }
    x[i].index=-1;

    _scale_instance(&x,svm->feature_dim,svm->max,svm->min);
    
    prob_estimates = (double *) rs_malloc(svm->n_classes*sizeof(double),"SVM probability estimates");
    
    svm_predict_probability(svm->model,x,prob_estimates);
    
	class_prob = prob_estimates[class_ind];
	rs_free (x);
	rs_free (prob_estimates);
	return class_prob;
}

bool event_handler_pdu_receive(node_t *node, node_t *incoming_node, mac_pdu_t *pdu)
{
    bool all_ok = TRUE;

    incoming_node->mac_info->error = FALSE; /* emulate a MAC acknowledgment */

    switch (pdu->type) {

        case MAC_TYPE_IP : {
            ip_pdu_t *ip_pdu = pdu->sdu;
            pdu->sdu = NULL;

            if (!ip_node_receive(node, incoming_node, ip_pdu)) {
                all_ok = FALSE;
            }

            break;
        }

        default:
            rs_error("node '%s': unknown MAC type '0x%04X'", node->phy_info->name, pdu->type);
            all_ok = FALSE;
    }

    return all_ok;
}

int _asegment_fixed(char *seg_info, dsp_sample_t *signal, int n_samples, dsp_sample_t ***signal_segment, int **length) {
	int i, frame_length, frame_shift;
	int n_segments =0;
	int *_length;
	dsp_sample_t **_segments;
	
	if (sscanf(seg_info,"%d:%d",&frame_length,&frame_shift) != 2) {
		rs_error("Frame length and/or frame shift information in wrong format!");
		return -1;
	}
	n_segments= (n_samples - frame_length) / frame_shift + 1;

	_segments = (dsp_sample_t **) rs_malloc(n_segments * sizeof(dsp_sample_t *),"Signal segments");
	_length = (int *) rs_malloc(n_segments*sizeof(int),"Segment lengths");

	for (i=0;i<n_segments;i++) {
		_segments[i] = (dsp_sample_t *) rs_malloc(frame_length * sizeof(dsp_sample_t),"signal segments"); 
		_length[i]=frame_length;
	
		if (!memcpy(_segments[i],signal+i*frame_shift,frame_length*sizeof(dsp_sample_t))) {
			rs_warning("Signal was shorter than expected!");
			return -1;
		}
	}

	*signal_segment=_segments;
	*length=_length;
	return n_segments;
}

char *rs_line_read(FILE *fp, char comment_char)
	{
	static char *line = NULL;

	char *cp;
	int len, i;

	/* evtl. Zeilenpuffer erzeugen ... */
	if (line == NULL)
		line = rs_malloc(_line_len * sizeof(char), "line buffer");

	/* ... und solange noch Zeilen gelesen werden koennen ... */
	while (fgets(line, _line_len, fp) != NULL) {
		/* ... ggf. '\n' am Zeilenende loeschen ... */
		while (line[(len = strlen(line)) - 1] != '\n') {
			/* ... bei Pufferueberlauf ggf. erweitern ... */
			rs_warning("line longer than %d characters read - expanding!",
				_line_len);

			/* ... falls ueberlange TEXT-Zeile ... */
			for (i = 0; i < len; i++)
				if (!(isprint(line[i]) || isspace(line[i])))
					rs_error("non-printable character '0x%02x' encountered in excess text line!", line[i]);

			_line_len += RS_LINE_LEN_DEFAULT;
			line = rs_realloc(line, _line_len * sizeof(char),
					"extended line buffer");

			if (fgets(line + len, _line_len - len, fp) == NULL) {
				len++;
				break;
				}
			}
		line[len - 1] = '\0';

		/* ... ggf. Kommentare ueberspringen ... */
		if (comment_char && line[0] == comment_char)
			continue;

		/* ... und am Zeilenende loeschen falls nicht "escaped" ... */
		if (comment_char) {
			cp = line + 1;
			while (cp = strrchr(cp, comment_char)) {
				if (cp[-1] != '\\') {
					*cp = '\0';
					break;
					}
				}
			}

		/* ... und Zeilen mit Inhalt zurueckgeben */
		for (cp = line; *cp; cp++)
			if (!isspace(*cp))
				return(line);
		}

	/* ... sonst Dateiende signalisieren */
	return(NULL);
	}

lsFloat_t * lsFloat_init(lsFloat_t * il)
{
  if (LS_isNIL(il)) {
    rs_error("lsFloat_init: got empty list");
  }
  LS_N(il)--;
  return (il);
}

rs_result rs_signature_init(rs_signature_t *sig, int magic, int block_len,
                            int strong_len, rs_long_t sig_fsize)
{
    int max_strong_len;

    /* Check and set default arguments. */
    magic = magic ? magic : RS_BLAKE2_SIG_MAGIC;
    switch (magic) {
    case RS_BLAKE2_SIG_MAGIC:
        max_strong_len = RS_BLAKE2_SUM_LENGTH;
        break;
    case RS_MD4_SIG_MAGIC:
        max_strong_len = RS_MD4_SUM_LENGTH;
        break;
    default:
        rs_error("invalid magic %#x", magic);
        return RS_BAD_MAGIC;
    }
    strong_len = strong_len ? strong_len : max_strong_len;
    if (strong_len < 1 || max_strong_len < strong_len) {
        rs_error("invalid strong_sum_len %d for magic %#x", strong_len, magic);
        return RS_PARAM_ERROR;
    }
    /* Set attributes from args. */
    sig->magic = magic;
    sig->block_len = block_len;
    sig->strong_sum_len = strong_len;
    sig->count = 0;
    /* Calculate the number of blocks if we have the signature file size. */
    /* Magic+header is 12 bytes, each block thereafter is 4 bytes
       weak_sum+strong_sum_len bytes */
    sig->size = (int)(sig_fsize ? (sig_fsize - 12) / (4 + strong_len) : 0);
    if (sig->size)
        sig->block_sigs =
            rs_alloc(sig->size * rs_block_sig_size(sig),
                     "signature->block_sigs");
    else
        sig->block_sigs = NULL;
    sig->hashtable = NULL;
#ifndef HASHTABLE_NSTATS
    sig->calc_strong_count = 0;
#endif
    rs_signature_check(sig);
    return RS_DONE;
}

svm_classifier_t *svm_finish_classifier(svm_classifier_t *svm) {
    int i, j, nr_fold=5, total_correct, best_correct=0, best_c=svm->param.C, best_g=svm->param.gamma;
    const char *error_msg;
    double *result = (double *) rs_malloc(sizeof(double)*svm->problem.l,"cross validation result");

    rs_msg("Building SVM classifier...");

    if (svm->finished)
	rs_warning("SVM classifier is already trained!");

    error_msg = svm_check_parameter(&(svm->problem),&(svm->param));
    
    if(error_msg) 
	rs_error("%s",error_msg);
    
    /* Skalierung */
    _create_scaling(svm->problem,svm->feature_dim,&(svm->max),&(svm->min));
    
    for (i=0;i<svm->problem.l;i++) 
	_scale_instance(&(svm->problem.x[i]),svm->feature_dim,svm->max,svm->min);
    
    /* Cross-Validation, um C und G zu bestimmen bei RBF-Kernel */
    if (svm->param.kernel_type == RBF) {
	svm->param.probability = 0;
	for (i=0;i<C_G_ITER;i++) {
	    total_correct=0;
	    svm->param.C=pow(2,C[i]);
	    svm->param.gamma=pow(2,G[i]);
	    svm_cross_validation(&(svm->problem),&(svm->param),nr_fold,result);
	    for(j=0;j<svm->problem.l;j++) {
		if(result[j] == svm->problem.y[j])
		    ++total_correct;
	    }
	    if (total_correct > best_correct) {
		best_correct=total_correct;
		best_c=C[i];
		best_g=G[i];
	    }
	    rs_msg("C-G-Selektion-Iteration # %d: tried c=%g and g=%g => CV rate is %g; current best c=%g and g=%g with CV rate %g",i+1,pow(2,C[i]),pow(2,G[i]),total_correct*100.0/svm->problem.l,pow(2,best_c),pow(2,best_g),best_correct*100.0/svm->problem.l);
	}
	
	/* Training */
	svm->param.C=pow(2,best_c);
	svm->param.gamma=pow(2,best_g);
	svm->param.probability = 1;
    }
    
    svm->model=svm_train(&(svm->problem),&(svm->param));
    svm->finished=1;

	// @begin_add_johannes
	rs_free (result);
	// @end_add_johannes

    return svm;
}