abw_conf.c

/*
 * Copyright (c) 2006, CESNET
 * All rights reserved.
 *
 * LICENSE TERMS
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the company nor the names of its contributors 
 *       may be used to endorse or promote products derived from this 
 *       software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, 
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY 
 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 
 * THE COMPANY OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * $Id$
 *
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <math.h>
#define __USE_XOPEN
#include <time.h>
#define _GNU_SOURCE
#include <getopt.h>
#include <readline/readline.h>
#include <readline/history.h>

#include "../../src/common/parseconf.h"
#include "abw_common.h"
#include "abw_conf.h"

extern int debug;

configuration_t configuration;

void usage() {
	char *progname="abw";

	fprintf(stderr, "%s: Usage: %s [options] [header_filter]\n", progname, progname);

	fprintf(stderr, "  -f or --conf_filename <filename>   read configuration from file\n");
	fprintf(stderr, "\nGeneral options:\n");
	fprintf(stderr, "  -h                             print this help message\n");
	fprintf(stderr, "  -D or --debug[=n]              set debug level to n\n");
	fprintf(stderr, "                                 (n can be specified with --debug only)\n");
	fprintf(stderr, "  -q or --no_stdout              do not print results on stdout\n");
	fprintf(stderr, "  --stdout_simple                print results as numbers only\n");
	fprintf(stderr, "  --no_measure                   do not start measurements\n");
	fprintf(stderr, "                                 (use with -D or --debug to check configuration)\n");
	fprintf(stderr, "\nSubject options:\n");
	fprintf(stderr, "  -n or --hostname <hostname>    hostname or IP address of measurement station\n");
	fprintf(stderr, "                                 (default localhost)\n");
	fprintf(stderr, "  -d or --device <device>        device on measurement station\n");
	fprintf(stderr, "                                 (e.g., /dev/combosix/0, /dev/dag0,\n");
	fprintf(stderr, "                                 default %s)\n", DEFAULT_INTERFACE);
	fprintf(stderr, "  --port <n>                     port on device, default is all ports together\n");
	fprintf(stderr, "  --mpls                         link uses MPLS\n");
	fprintf(stderr, "  -l or --link_mbps <mbps>       link installed bandwidth (default %d)\n", DEFAULT_LINK_MBPS);
	fprintf(stderr, "\nParameters options:\n");
	fprintf(stderr, "  -m or --sau_mode {d | b | p}   sampling mode (default deterministic)\n");
	fprintf(stderr, "      d - deterministic\n");
	fprintf(stderr, "      b - byte deterministic\n");
	fprintf(stderr, "      p - probabilistic\n");
	fprintf(stderr, "  -r or --sau_threshold <threshold>  pass packet when threshold is reached\n");
	fprintf(stderr, "      number of packets for d, number of bytes for b and\n");
	fprintf(stderr, "      pass probability for p (default 1 for all modes)\n");
	fprintf(stderr, "  -w or --payload_string <word>  word to be searched in payload,\n");
	fprintf(stderr, "                                 for multiple -w, packet passes when at least\n");
	fprintf(stderr, "                                 one word matches\n");
	fprintf(stderr, "  -i or --interval <interval>    seconds between measurements (default 1)\n");
	fprintf(stderr, "\nMeasurement options:\n");
	fprintf(stderr, "  --protocols <protocols>        comma-separated list of protocols\n");
	fprintf(stderr, "                                 (default all, which means all packets)\n");

	exit(-1);
} /* usage() */

int read_command_line(int argc, char *argv[], configuration_t *configuration) {

	int payload_strings_no;
	double interval;
	int direct_flow;
	int opt;
	int opt_idx;

	if (configuration==NULL) {
		fprintf(stderr, "%s: configuration argument is NULL\n", __func__);
		return -1;
	}

	payload_strings_no=0;
	direct_flow=0;

	while ((opt=getopt_long(argc, argv, ARGS, long_options, &opt_idx)) != -1) {
  	switch(opt) {

		/* General options */
		case 'h':
			usage();
			exit(0);
		case 'D':
		case LO_DEBUG:
			if (optarg)
				debug=atoi(optarg);
			else
				debug=1;
			break;
		case LO_NO_MEASURE:
         configuration->global->no_measure=1;
         break;
		case 'q':
		case LO_NO_STDOUT:
			configuration->global->no_stdout=1;
			break;
		case LO_STDOUT_SIMPLE:
			configuration->global->stdout_simple=1;
			break;

		/* Subject options */
		case 'n':
		case LO_HOSTNAME:
			direct_flow=1;
			configuration->subject->hostname=optarg;
			break;
		case 'd':
		case LO_INTERFACE:
			direct_flow=1;
	  		configuration->subject->interface=optarg;
		  	break;
		case LO_PORT:
			/* check here, because -1 given here would look as correct default 
				value for check_conf() */
			if (atoi(optarg)<0) {
				fprintf(stderr, "%s: port number must be >= 0\n", __func__);
				return -1;
			}
			configuration->subject->port=atoi(optarg);
		case 'l':
		case LO_LINK_MBPS:
			direct_flow=1;
			configuration->subject->link_mbps=atoi(optarg);
			if (configuration->subject->link_mbps<=0) {
				fprintf(stderr, "%s: link installed bandwidth must be positive\n", 
					__func__);
				return -1;
			}
			break;
		case LO_MPLS:
			direct_flow=1;
			configuration->subject->mpls=1;
			break;

		/* Parameters options */
		case 'm':
		case LO_SAU_MODE:
			direct_flow=1;
			if (strlen(optarg)>1) {
				fprintf(stderr, "%s: sampling mode must be d, b or p\n", __func__);
				return -1;
			}
			configuration->parameters->sau_mode=optarg[0];
			break;
		case 'r':
		case LO_SAU_THRESHOLD:
			direct_flow=1;
			configuration->parameters->sau_threshold=atof(optarg);
			break;
		case 'w':
		case LO_PAYLOAD_STRING:
			/* We let user to specify more payload strings on a command-line
				(each as a word without spaces), but current implementation
				passes only the first string to searching mechanism */
			direct_flow=1;
			if (payload_strings_no >= MAX_PAYLOAD_STRINGS) {
				fprintf(stderr, "%s: max. %d strings can be searched in payload\n",
					 __func__, MAX_PAYLOAD_STRINGS);
				return -1;
			}
			if (strlen(optarg) > MAX_PAYLOAD_STRING) {
				fprintf(stderr, "%s: max. %d characters long strings can be searched in payload\n", __func__, MAX_PAYLOAD_STRING);
				return -1;
			}
			if ((configuration->parameters->payload_strings[payload_strings_no]=
					malloc(strlen(optarg)+1))==NULL) {
				fprintf(stderr, "%s: malloc() failed\n", __func__);
				return -1;
			}
			strcpy(configuration->parameters->payload_strings[payload_strings_no], 
				optarg);
			payload_strings_no++;
			break;
		case 'i':
		case LO_INTERVAL:
			direct_flow=1;
			interval=atof(optarg);
			if (interval<=0) {
				fprintf(stderr, "%s: interval must be positive\n", __func__);
				return -1;
			}
			configuration->parameters->interval.tv_sec=floor(interval);
			configuration->parameters->interval.tv_usec=
				(int)floor((interval - configuration->parameters->interval.tv_sec) * 1000000);
			break;

		/* Measurement options */
		case LO_PROTOCOLS:
			configuration->measurement->protocols=optarg;
			break;

		/* Read flow configuration from configuration file */
		case 'f':
		case LO_CONF_FILENAME:
			configuration->global->conf_filename=optarg;
			break;

		default:
			usage();
			return -1;
	  }
  }

	if (direct_flow && configuration->global->conf_filename) {
		fprintf(stderr, "%s: configuration can be read from one source only - command line or configuration file\n", __func__);
		return -1;
	}

	/* If we do not specify any command-line arguments, use direct flow
		with default subject and parameters */

	if (argc==1) {
		direct_flow=1;
		configuration->subject->hostname=DEFAULT_HOSTNAME;
		configuration->subject->interface=DEFAULT_INTERFACE;
	}

	if (direct_flow) {
		configuration->subject->id=1;
		configuration->scope->id=1;
		configuration->scope->subject_ids="1";
		configuration->parameters->id=1;
		configuration->measurement->id=1;
		configuration->measurement->scope_id=1;
		configuration->measurement->parameters_id=1;
	}

	return 0;
} /* read_command_line() */

int read_conf_file(configuration_t *configuration)
{
   conf_category_entry_t *cat;
   conf_parameter_t *param;
	int payload_strings_no;
	subject_t **subject;
	scope_t **scope;
	parameters_t **parameters;
	measurement_t **measurement;

   if (configuration==NULL || configuration->global->conf_filename==NULL) {
      fprintf(stderr, "%s: some of the required arguments were not specified\n",
			__func__);
      return -1;
   }

	/* Parse configuration file and load its content into a sequence of
		structures representing categories and their items in the file */
   if (pc_load(configuration->global->conf_filename)!=1) {
      fprintf(stderr, "%s: pc_load() did not load file %s\n", __func__,
         configuration->global->conf_filename);
      return -1;
   }

	/* Go over all categories */
	subject=&(configuration->subject);
	scope=&(configuration->scope);
	parameters=&(configuration->parameters);
	measurement=&(configuration->measurement);

	cat=pc_get_category("global");
	if (cat) {

		param=cat->params;
		while (param) {
			param=param->next;
		}
	}

	cat=pc_get_category("subject");
	while (cat) {

		if (*subject==NULL) {
			if ((*subject=new_subject())==NULL) {
				fprintf(stderr, "%s: new_subject() failed\n", __func__);
				return -1;
			}
		}

		param=cat->params;
		while (param) {

			if (!strcmp(param->name, "id"))
            (*subject)->id=atoi(param->value);

			else if (!strcmp(param->name, "hostname")) {
				if (((*subject)->hostname=malloc(strlen(param->value)+1))==NULL) {
					fprintf(stderr, "%s: malloc() failed\n", __func__);
					return -1;
				}
				strcpy((*subject)->hostname, param->value);
			}

			else if (!strcmp(param->name, "interface")) {
				if (((*subject)->interface=malloc(strlen(param->value)+1))==NULL) {
					fprintf(stderr, "%s: malloc() failed\n", __func__);
					return -1;
				}
				strcpy((*subject)->interface, param->value);
			}

			else if (!strcmp(param->name, "port")) {
				/* check here, because -1 given here would look as correct default
               value for check_conf() */
				if (atoi(param->value) < 0) {
					fprintf(stderr, "%s: port number must be >= 0\n", __func__);
					return -1;
				}
        		(*subject)->port=atoi(param->value);
			}

			else if (!strcmp(param->name, "link_mbps"))
        		(*subject)->link_mbps=atoi(param->value);

			else if (!strcmp(param->name, "mpls")) {
				if (!strcmp(param->value, "yes"))
					(*subject)->mpls=1;
				else if (!strcmp(param->value, "no"))
					(*subject)->mpls=0;
				else {
					fprintf(stderr, "%s: mpls must be \"yes\" or \"no\"\n", 
						__func__);
					return -1;
				}
			}

			else if (!strcmp(param->name, "label")) {
				if (((*subject)->label=malloc(strlen(param->value)+1))==NULL) {
					fprintf(stderr, "%s: malloc() failed\n", __func__);
					return -1;
				}
				strcpy((*subject)->label, param->value);
			}

			else if (!strcmp(param->name, "description")) {
				if (((*subject)->description=malloc(strlen(param->value)+1))==NULL) {
					fprintf(stderr, "%s: malloc() failed\n", __func__);
					return -1;
				}
				strcpy((*subject)->description, param->value);
			}
		
			else if (!strcmp(param->name, "direction")) {
				if (!strcmp(param->value, "out"))
					(*subject)->out=1;
				else if (!strcmp(param->value, "in"))
					(*subject)->out=0; /* default, just for sure */
				else {
					fprintf(stderr, "%s: direction must be in or out\n", __func__);
					return -1;
				}
			}

			param=param->next;
		} /* while (param) */
		cat=cat->next;
		subject=&((*subject)->next);
	} /* while (cat) "subject" */
		
	cat=pc_get_category("scope");
	while (cat) {

		if (*scope==NULL) {
			if ((*scope=new_scope())==NULL) {
				fprintf(stderr, "%s: new_subject() failed\n", __func__);
				return -1;
			}
		}

		param=cat->params;
		while (param) {

			if (!strcmp(param->name, "id"))
            (*scope)->id=atoi(param->value);

			else if (!strcmp(param->name, "subject_ids")) {
				if (((*scope)->subject_ids=malloc(strlen(param->value)+1))==NULL) {
					fprintf(stderr, "%s: malloc() failed\n", __func__);
					return -1;
				}
				strcpy((*scope)->subject_ids, param->value);
			}

			param=param->next;
		} /* while (param) */
		cat=cat->next;
		scope=&((*scope)->next);
	} /* while (cat) "scope" */
		
	cat=pc_get_category("parameters");
	while (cat) {

		if (*parameters==NULL) {
			if ((*parameters=new_parameters())==NULL) {
				fprintf(stderr, "%s: new_parameters() failed\n", __func__);
				return -1;
			}
		}

		payload_strings_no=0;
		param=cat->params;
		while (param) {

			if (!strcmp(param->name, "id"))
				(*parameters)->id=atoi(param->value);

			else if (!strcmp(param->name, "header_filter")) {
				if (strlen(param->value)>=MAX_HEADER_FILTER) {
					fprintf(stderr, "%s: header filter string must not be longer than %d characters\n", __func__, MAX_HEADER_FILTER);
					return -1;
				}
				if (((*parameters)->header_filter=
					malloc(strlen(param->value)+1))==NULL) {
						fprintf(stderr, "%s: malloc() failed\n", __func__);
						return -1;
				}
				strcpy((*parameters)->header_filter, param->value);
			}

			else if (!strcmp(param->name, "sau_mode"))
				(*parameters)->sau_mode=param->value[0];

			else if (!strcmp(param->name, "sau_threshold"))
				(*parameters)->sau_threshold=atof(param->value);

			else if (!strcmp(param->name, "payload_string")) {
				if (payload_strings_no >= MAX_PAYLOAD_STRINGS) {
           		fprintf(stderr, "%s: max. %d strings can be searched in payload\n", __func__, MAX_PAYLOAD_STRINGS);
           		return -1;
        		}
        		if (strlen(param->value) > MAX_PAYLOAD_STRING) {
           		fprintf(stderr, "%s: max. %d characters long strings can be searched in payload\n", __func__, MAX_PAYLOAD_STRING);
           		return -1;
        		}
        		if (((*parameters)->payload_strings[payload_strings_no]=
              	malloc(strlen(param->value)+1))==NULL) {
           		fprintf(stderr, "%s: malloc() failed\n", __func__);
           		return -1;
        		}
        		strcpy((*parameters)->payload_strings[payload_strings_no], 
					param->value);
        		payload_strings_no++;
			}
				
			else if (!strcmp(param->name, "interval_sec"))
				(*parameters)->interval.tv_sec=atoi(param->value);

			else if (!strcmp(param->name, "interval_usec"))
				(*parameters)->interval.tv_usec=atoi(param->value);

			param=param->next;
		} /* while (param) */
		cat=cat->next;
		parameters=&((*parameters)->next);
	} /* while (cat) "parameters" */

	cat=pc_get_category("measurement");
	while (cat) {

		if (*measurement==NULL) {
			if ((*measurement=new_measurement())==NULL) {
				fprintf(stderr, "%s: new_measurement() failed\n", __func__);
				return -1;
			}
		}

		param=cat->params;
		while (param) {

			if (!strcmp(param->name, "id"))
              (*measurement)->id=atoi(param->value);

			if (!strcmp(param->name, "scope_id"))
              (*measurement)->scope_id=atoi(param->value);

			else if (!strcmp(param->name, "parameters_id"))
              (*measurement)->parameters_id=atoi(param->value);

			else if (!strcmp(param->name, "protocols")) {
				if ((*measurement)->protocols) {
					fprintf(stderr, "%s: only one protocols string can be specified\n", __func__);
					return -1;
				}
				if (strlen(param->value) > MAX_PROTOCOLS_STRING) {
               fprintf(stderr, "%s: max. %d characters long protocols string can be specified\n", __func__, MAX_PROTOCOLS_STRING);
               return -1;
            }
            if (((*measurement)->protocols=
						malloc(strlen(param->value)+1))==NULL) {
               fprintf(stderr, "%s: malloc() failed\n", __func__);
               return -1;
            }
				strcpy((*measurement)->protocols, param->value);
			}

			param=param->next;
		} /* while (param) */
		cat=cat->next;
		measurement=&((*measurement)->next);
	} /* while (cat) "measurement" */

	pc_close();

	return 0;
} /* read_conf_file() */

int read_const_conf_file(configuration_t *configuration)
{
   conf_category_entry_t *cat;
	subject_t *subject;
	char *hostname, *interface, *mpls, *link_mbps;

   if (configuration==NULL) {
      fprintf(stderr, "%s: some of the required arguments were not specified\n",
			__func__);
      return -1;
   }

	/* 
	 * Parse configuration file and load its content into a sequence of
	 * structures representing categories and their items in the file.
    * This file is optional, if we cannot load it, just return. 
	 */
   if (pc_load(ABW_CONST_CFG)!=1) 
		return 0;

	/* Go over all [subject] sections */
	
	cat=pc_get_category("subject");
	while (cat) {

		hostname=pc_get_param(cat, "hostname");
		interface=pc_get_param(cat, "interface");

		mpls=pc_get_param(cat, "mpls");
		link_mbps=pc_get_param(cat, "link_mbps");

		/* 
		 * If this [subject] section does not include hostname or interface
		 * (which are both needed to identify subject) or if it does not
		 * include any information about subject to be stored in configuration
		 * then skip this [subject] section.
		 */

		if (hostname==NULL || interface==NULL ||
			 (mpls==NULL && link_mbps==NULL)) {
			cat=cat->next;
			continue;
		}

		subject=configuration->subject;
		while (subject) {
			if (subject->hostname && !strcmp(subject->hostname, hostname) && 
				 subject->interface && !strcmp(subject->interface, interface)) {
				if (mpls && !strcmp(mpls, "yes"))
					subject->mpls=1;
				if (link_mbps)
					subject->link_mbps=atoi(link_mbps);
				break;
			}
			subject=subject->next;
		}

		cat=cat->next;
	} /* while (cat) "subject" */
		
	pc_close();

	return 0;
} /* read_const_conf_file() */

/* Note that readline() uses malloc() to allocate memory */
/* int read_password(global_spec_t *global_spec) {

	if (global_spec->conf_from_mysql || global_spec->conf_to_mysql ||
		 global_spec->clear_conf || global_spec->db) {
		if  (!global_spec->db || !global_spec->user) {
			fprintf(stderr, "%s: if MySQL operation is requested, you also have to specify MySQL database name, username and password\n", __func__);
			return -1;
		}
		if (!global_spec->passwd) {
			if ((global_spec->passwd=readline("MySQL password: "))==NULL) {
				fprintf(stderr, "%s: Invalid MySQL password\n", __func__);
				return -1;
			}
		}
	}
	return 0;
} */ /* read_password() */

int check_conf(configuration_t *configuration) {
	subject_t *subject;
	scope_t *scope;
	parameters_t *parameters;
	measurement_t *measurement;

	int subject_no;
	int protocols_no;

	int i;

	if (configuration==NULL) {
		fprintf(stderr, "%s: empty configuration\n", __func__);
		return -1;
	}

	/* Check subjects */

   subject=configuration->subject;
   while (subject) {

		if (subject->id <= 0) {
			fprintf(stderr, "%s: id in [subject] section must be greater than zero\n and is %d", __func__, subject->id);
			return -1;
		}
	
		if (subject->hostname == NULL) {
			fprintf(stderr, "%s: you must specify hostname\n", __func__);
			return -1;
		}

		if (subject->interface == NULL) {
			fprintf(stderr, "%s: you must specify interface\n", __func__);
			return -1;
		}

		if (subject->label == NULL) {
			fprintf(stderr, "%s: you must specify label\n", __func__);
			return -1;
		}

		subject=subject->next;
	} /* while (subject) */

	/* Check scopes */

   scope=configuration->scope;
   while (scope) {

		if (scope->id <= 0) {
			fprintf(stderr, "%s: id in [scope] section must be greater than zero\n", __func__);
			return -1;
		}
	
		if (scope->subject_ids == NULL) {
			fprintf(stderr, "%s: you must specify subject_ids in [scope] section\n", __func__);
			return -1;
		}

		if ((subject_no=split_strings(scope->subject_ids, MAX_SUBJECTS,
				scope->subject_array))<=0) {
			fprintf(stderr, "%s: split_strings() failed\n", __func__);
			return -1;
		}

		for (i=0; i<subject_no; i++) {
			int mpls, port;

			subject=configuration->subject;
			while (subject) {
				if (subject->id == atoi(scope->subject_array[i])) {
					scope->subject[i]=subject;
					break;
				}
				subject=subject->next;
			}
			if (!(scope->subject[i])) {
         	fprintf(stderr, 
					"%s: cannot find subject %d refered by scope %d\n",
            		__func__, atoi(scope->subject_array[i]), scope->id);
         	return -1;
      	}

			if (i==0) {
				mpls=scope->subject[i]->mpls;
				port=scope->subject[i]->port;
			}
			else {
				if (mpls != scope->subject[i]->mpls) {
					fprintf(stderr, "%s: mpls must be the same in all subjects in a scope\n", __func__);
					return -1;
				}
				if (port != scope->subject[i]->port) {
					fprintf(stderr, "%s: port must be the same in all subjects in a scope\n", __func__);
					return -1;
				}
			}
		}

		scope->subject_no = subject_no;

		scope=scope->next;
	} /* while (scope) */

	/* Check parameters */

   parameters=configuration->parameters;
   while (parameters) {

		if (parameters->id <= 0) {
         fprintf(stderr, "%s: id in [parameters] section must be greater than zero\n", __func__);
         return -1;
      }

		if (parameters->sau_mode!='d' && parameters->sau_mode!='b' && 
			 parameters->sau_mode!='p') {
			fprintf(stderr, "%s: sampling mode must be d, b or p\n", __func__);
	  		return -1;
		}

		if (parameters->sau_mode=='p') {
			if (parameters->sau_threshold<0 || parameters->sau_threshold>1) {
		  			fprintf(stderr, "%s: pass probability must be between 0 and 1\n",
						 __func__);
	  	  			return -1;
	  			}
	  		parameters->sau_threshold=
				(floor)(0xFFFFFFFF * (1 - parameters->sau_threshold));
	  		parameters->sau_mode_encoded=COMBO6_PROBABILISTIC;
  		}
  		else if (parameters->sau_mode=='b') {
	  		if (parameters->sau_threshold<0) {
	  			fprintf(stderr, "%s: byte threshold cannot be negative\n", 
					__func__);
	  			return -1;
  			}
			parameters->sau_threshold=(floor)(parameters->sau_threshold);
  			parameters->sau_mode_encoded=COMBO6_LENGTH_DETERMINISTIC;
		}
  		else {
  			if (parameters->sau_threshold<0) {
	  			fprintf(stderr, "%s: packet threshold cannot be negative\n", 
					__func__);
	  			return -1;
  			}
		   parameters->sau_threshold=(floor)(parameters->sau_threshold);
  			parameters->sau_mode_encoded=COMBO6_DETERMINISTIC;
		}

		if (parameters->sau_mode=='b') {
			fprintf(stderr, "%s: byte probabilistic sampling is not supported in this version\n", __func__);
			return -1;
		}

		if (parameters->payload_strings[1]) {
			fprintf(stderr, "%s: payload searching for multiple strings is not supported in this version\n", __func__);
			return -1;
		}

		if (parameters->interval.tv_sec<0 || parameters->interval.tv_usec<0 || 
			 parameters->interval.tv_usec>=1000000 ||
			 (parameters->interval.tv_sec==0 && parameters->interval.tv_usec==0)) {
			fprintf(stderr, "%s: incorrect interval value\n", __func__);
			return -1;
		}

		parameters=parameters->next;
	} /* while (parameters) */

	/* Check measurements */

	measurement=configuration->measurement; 
	while (measurement) {

		if (measurement->id <= 0) {
         fprintf(stderr, "%s: id in [measurement] section must be greater than zero\n", __func__);
         return -1;
      }
		if (measurement->scope_id <= 0) {
			fprintf(stderr, "%s: scope_id in [measurement] section must be greater than zero\n", __func__);
			return -1;
		}
		if (measurement->parameters_id <= 0) {
			fprintf(stderr, "%s: parameters_id in [measurement] section must be greater than zero\n", __func__);
			return -1;
		}

		/* Set default protocol string */

		if (!(measurement->protocols)) {
			if ((measurement->protocols=malloc(strlen("all")+1))==NULL) {
				fprintf(stderr, "%s: malloc() failed\n", __func__);
				return -1;
			}
			strcpy(measurement->protocols, "all");
		}

		/* Split protocol string into individual protocols */

		if ((protocols_no=split_strings(measurement->protocols, MAX_PROTOCOLS,
				measurement->protocols_array))<0) {
			fprintf(stderr, "%s: split_strings() failed\n", __func__);
			return -1;
		}

		/* Sort individual protocols alphabetically */

		qsort(measurement->protocols_array, protocols_no, (size_t)sizeof(char *),
			 compstr);

		/* Replace protocols string with the sorted one */

		free(measurement->protocols);
		if (concat_strings(&(measurement->protocols), MAX_PROTOCOLS,
				measurement->protocols_array)<0) {
			fprintf(stderr, "%s: concat_strings() failed\n", __func__);
			return -1;
		}
	
		/* Check references and set pointers */

		scope=configuration->scope;
		while (scope) {
			if (scope->id == measurement->scope_id) {
				measurement->scope=scope;
				break;
			}
			scope=scope->next;
		}
		if (!(measurement->scope)) {
			fprintf(stderr, "%s: cannot find scope refered by measurement %d\n",
				__func__, measurement->id);
			return -1;
		}

		parameters=configuration->parameters;
		while (parameters) {
			if (parameters->id == measurement->parameters_id) {
				measurement->parameters=parameters;
				break;
			}
			parameters=parameters->next;
		}
		if (!(measurement->parameters)) {
			fprintf(stderr, "%s: cannot find parameters refered by measurement %d\n",
				__func__, measurement->id);
			return -1;
		}

		measurement=measurement->next;
	} /* while (measurement) */

	return 0;
} /* check_conf() */

int print_conf(configuration_t *configuration) {
	measurement_t *measurement;
	char *ch, **chch;
   int i, j;

	if (configuration==NULL) {
		fprintf(stderr, "%s: empty configuration\n", __func__);	
		return -1;
	}

	/* Print global configuration */

	if (configuration->global->conf_filename)
		printf("global->conf_filename: %s\n", configuration->global->conf_filename);
	else
		printf("global->conf_filename: unspecified\n");

	printf("global->no_measure: %d\n", configuration->global->no_measure);
	printf("global->no_stdout: %d\n", configuration->global->no_stdout);
	printf("global->stdout_simple: %d\n", configuration->global->stdout_simple);

	/* Print measurements */

	measurement=configuration->measurement;
   while (measurement) {

		printf("\nmeasurement:\n");
		printf("id: %d\n", measurement->id);
		printf("scope_id: %d\n", measurement->scope_id);
		printf("parameters_id: %d\n", measurement->parameters_id);
		printf("protocols: %s\n", measurement->protocols); 

		/* Print subjects */

		i=0;
		while (i<MAX_SUBJECTS && measurement->scope->subject[i]) {
			printf("subject:\n");
			printf("id: %d\n", measurement->scope->subject[i]->id);
			printf("hostname: %s\n", measurement->scope->subject[i]->hostname);
			printf("interface: %s\n", measurement->scope->subject[i]->interface);
			printf("port: %d\n", measurement->scope->subject[i]->port);
			printf("mpls: %d\n", measurement->scope->subject[i]->mpls);
  			printf("link_mbps: %d\n", measurement->scope->subject[i]->link_mbps);
			printf("label: %s\n", measurement->scope->subject[i]->label);
			if (measurement->scope->subject[i]->description)
  				printf("description: %s\n", measurement->scope->subject[i]->description);
			else
				printf("description: unspecified\n");
			printf("direction: %s\n", (measurement->scope->subject[i]->out)?
				"out":"in");
			i++;
		}
	
		/* Print parameters */

		printf("parameters:\n");
		if (measurement->parameters->header_filter)
			printf("header_filter: %s\n", measurement->parameters->header_filter);
		else
			printf("header_filter: unspecified\n");

		printf("sau_mode: %c, sau_threshold: %u\n", 
			measurement->parameters->sau_mode, 
			(unsigned int)(floor(measurement->parameters->sau_threshold)));

		chch=measurement->parameters->payload_strings; 
		j=0;
   	if (*chch) {
			printf("payload_strings:");
			while (j<MAX_PAYLOAD_STRINGS && *chch) {
				ch=*chch;
      		if (j>0)
         		printf(",");
      		printf(" |%s|", ch);
				chch++; j++;
			}
   		printf("\n");
		}
		else
			printf("payload_strings: unspecified\n");
 
  		printf("interval.tv_sec: %d, interval.tv_usec: %d\n", 
			(int)(measurement->parameters->interval.tv_sec), 
			(int)(measurement->parameters->interval.tv_usec));

		measurement=measurement->next;
	} /* while (measurement) */

	return 0;
} /* print_conf() */

int read_header_filter(int argc, char *argv[], char **p) {
	char header_filter[MAX_HEADER_FILTER+1];
	int i;

	header_filter[0]='\0';
	*p=NULL;

  	for (i=optind; i<argc; i++) {
  		if ((strlen(header_filter) + strlen(argv[i])) < MAX_HEADER_FILTER) {
	  		if (i>optind)
		  		strcat(header_filter, " ");
	  		strcat(header_filter, argv[i]);
	  	}
	  	else {
			fprintf(stderr, "%s: header filter string must not be longer than %d characters\n", __func__, MAX_HEADER_FILTER);
	  		exit(-1);
		}
  	}

	if (header_filter[0]) {
		if ((*p=malloc(strlen(header_filter)+1))==NULL) {
			fprintf(stderr, "%s: malloc() failed\n", __func__);
			return -1;
		}
		strcpy(*p, header_filter);
	}
	return 0;
} /* read_header_filter() */