PeerStreamer

/*

 */

#include	<stdio.h>

#include	<event2/event.h>

struct event_base *eventbase = NULL;

#endif

/** Initialize the software. This should be called FIRST */

	eventbase = event2_base;

#if 0

	/* Won't need this for normal operation */

#endif

}

	event_base_loop(eventbase, EVLOOP_ONCE);

}

}

	struct timeval t = { 0,0 };

	if (start) t = *start;

	struct periodic *h = malloc(sizeof(struct periodic));

	return h;

}

	struct periodic *p = h;

	p->frequency = 0.0;

}

/*

 */

#define _GNU_SOURCE

#include	<stdio.h>

#include	<stdlib.h>

#include	<stdarg.h>

#include	"dclog.h"

DCLog *dclog = NULL;

char *logbuffer = NULL;

size_t logbuffer_size = 0;

        if (initialized) return;

        /* Initialize the logger facility */

        initialized = 1;

}

	if (!initialized) return;

	DCLogClose(dclog);

	initialized = 0;

}

	va_list str_args;

	if (!initialized) return;

 * 

 */

/** A NeighborListEntry holds information for Peers in the NeighborList */

typedef struct {

 * Overall considerations:

	-# In the prototype, the Repository operates as a cental network resource (server). However, peers

may execute several repoclient instances, and connect to several Repository servers at the same time.

	-# The repository controller uses an internal network protocol for querying and publishing (inserting) measurement records, and this API defines the client side of this protocol.

	-# The following kinds of queries are supported:

		-# Metadata query: list of available (or implemented/supported) 

		in the same format what is used for the Publish call.  Missing (NULL-valued) fields are omitted.

*/

#include	"mon.h"

/** Constraints are used in GetPeer and CountPeer functions to specify matching criteria for numeric-value MeasurementRecords */

/** @file ul.h

 * 

 * 

 * There are two major operation modes:

 *	- player: displays the received video stream, and provides basic 

 *		controls (e.g. start/stop, channel switch etc.)

 * These operations are referred to as <i>chunkization</i>/<i>de-chunkization</i>.

 * 

 * In order to provide maximum flexibility, these processes are loosely coupled 

 * interaction.

 *

 * This interface is conceptually clean, easy to integrate with other programs, 

 * and straightforward to implement.

 *

 * At the ingestion side, it receives chunks sent by a <i>sequencer</i> in approximately correct timing. 

 * and (if possible) again with a roughly correct timing. 

 * As a simple approach, each receiver/player client may request a delay 

 * ingestion events offset by this delay.

 * 

 * This approach also decouples the `network' and `multimedia' aspects of the software: 

 * (e.g. with codec legal and technology aspects).

 * `Roughly correct timing'  means that the sending time for chunks are synchronized 

 * (to the media time they contain) with an accuracy of about or less than one chunk period. 

 * and the dechunkizers will also have to buffer only a small number of (1-3) chunks. 

 * 

 * For low-level interface, we propose using HTTP POST operations: HTTP is a well-known protocol 

 * HTTP interfaces are also easy to test.

 * 

 * The application may support  multiple simultaneous clients (players with different delays, analyzers, etc.) 

 * service used by the chunkizer to send new chunks.

 *

 * <b> Source (ingestor) Protocol Description</b>

 * from the ingestor. The format is a follows:<br>

 * <tt>http://<addr>:<port>/<path-id>/<chunk-number>?timestamp=<date></tt><br>

 * accompanied by the binary chunk in the POST message

 *

 * <b> Player (client) Protocol Description: Control Interface</b>

 * 

 * from clients (e.g. Display/GUI or analyzer modules). 

 * Registrations are encoded as HTTP GET requests as follows:

 * <tt>http://<hostname>:<port>/register-receptor?url=<url>&channel=<channel>&delay=<delay>&validity=<validity></tt><br>

 * Parameters are:

 *	- <url> the URL where posts should be sent (URL encoded). MANDATORY.

 *	- <channel> channel identifier

 * 	- <delay> the delay, expressed in seconds, fractional values are supported. Delay defaults to 5 seconds.

 * 	- <validity> TImeout for this registration: if there is no additional registration 

 * 

 * Then, each registered client module is supposed to implement a HTTP listener on the specified URL  

 * above.

 * The client-registration HTTP service above can be easily extended with optional commands implementing GUI

 * controls.

 * 

 */

/**

  Initialize source functionality within a peer's User Layer.

/**

  Initialize a `player' (dechunkizer) functionality  within a peer's User Layer..

  @return a handle for the initized peer UL or NULL on error

*/

HANDLE initULPeer(const char *reg_url);

#include "measure_manager.h"

#include "errors.h"

#include "ctrl_msg.h"

#ifndef WIN32

#include "measure_plugin.h"

#include "measure_dispatcher.h"

#define MAX_NUM_MEASURES_INSTANTIATED 1000000

#include "measure_dispatcher.h"

#include "measure_manager.h"

#include "mon_event.h"

MonMeasure::MonMeasure(class MeasurePlugin *mp, MeasurementCapabilities mc, class MeasureDispatcher *ptrDisp) {

	rx_cnt = 0;

#include "result_buffer.h"

#include "ml.h"

#include <fstream>

 ***********************************************************************/

#define LOG_MODULE "[monl] "

#include "ml.h"

#include "mon.h"

#include "measure_manager.h"

 ***************************************************************************/

#include "capprobe_measure.h"

#include <sys/time.h>

#include <math.h>

#include <string>

 ***********************************************************************/

#include "clockdrift_measure.h"

#include <math.h>

#include "corrected_delay_measure.h"

#include "clockdrift_measure.h"

#include <math.h>

CorrecteddelayMeasure::CorrecteddelayMeasure(class MeasurePlugin *m, MeasurementCapabilities mc, class MeasureDispatcher *md): MonMeasure(m,mc,md) {

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA 

 ***********************************************************************/

#include "forecaster_measure.h"

#include <sys/time.h>

#include <limits.h>

 ***********************************************************************/

#include "loss_burst_measure.h"

LossBurstMeasure::LossBurstMeasure(class MeasurePlugin *m, MeasurementCapabilities mc, class MeasureDispatcher *md): MonMeasure(m,mc,md) {

}

 ***********************************************************************/

#include "loss_measure.h"

LossMeasure::LossMeasure(class MeasurePlugin *m, MeasurementCapabilities mc, class MeasureDispatcher *md): MonMeasure(m,mc,md) {

	mSeqWin = NULL;

#include "result_buffer.h"

#include "errors.h"

#include "repoclient.h"

#include "mon_event.h"

#include "ml.h"

#include "mon.h"

class ResultBuffer {

private:

#include        <event2/http.h>

#include        <event2/http_struct.h>

#include	<mon.h>		// for MeasurementRecord

#include	<repoclient.h>

		recv_localsocketID_cb, eventbase);

	while (!messaging_ready) {

	}

	mlRegisterRecvDataCb(recv_data_from_peer_cb, MSG_TYPE_CHUNK);

	mlRegisterRecvDataCb(recv_keepalive_from_peer_cb, MSG_TYPE_ML_KEEPALIVE);

	// Initialize logging

	if (log_level == -1) log_level = cfg_getint(log_config, "level");

			cfg_getstr(log_config, "filemode"));

	// Check config file

	int fd = open(argv[argc - 1], 0);

#include	<event2/http_struct.h>

#include	<confuse.h>

#include	<ml.h>

#include	<mon.h>

#include	<chunk.h>

	int publishPeerIDPeriod =  cfg_getint(som_config,

			"publishPeerIDPeriod");

	if (publishPeerIDPeriod) 

				publish_PeerID, NULL);

	/* If we are passive, we need to figure out who is the server, and send

			fatal("Unable to start the HTTP receiver to http://%s:%d", 

					addr, port);

	} else fatal("Unable to parse stream specification %s", stream);

}

struct source_stream {

		src->buffers[src->num_buffers] = malloc(MAX_PACKET_SIZE);

	src->atts_size = 0;

}

#include <math.h>

#include "ml.h"

#include "transmissionHandler.h"

int peerID;

	numOfMsg = inputRate / ((msgLen/1349 + 1)*23 + msgLen)*timeInterval;	

	// Initialize logging

	//initRateLimiter(eventbase);

#include "ml.h"

#include "mon.h"

#include "repoclient.h"

int active = 0; // active or passive?

	printf("Running conf:\nIP: %s\nSTUN: %s\nREPO: %s\nACTIVE: %s\nVERBOSITY: %d\n", bind_ip ? bind_ip:"auto", stun_server, repository, active ? "active" : "passive", verbosity);

	// Initialize logging

	//Init monitoring layer

	monInit(eventbase, NULL);

#include "ml.h"

#include "mon.h"

#include "repoclient.h"

#define SOCKETID_PUBLISH_NAME "SocketId"

	printf("Running conf:\nIP:\t\t%s\nSTUN:\t\t%s\nREPO:\t\t%s\nVERBOSITY:\t%d\nPORT:\t\t%d\nCYCLE:\t\t%ds\nCHANNEL:\t%s\nPAUSE:\t\t%dms\n", bind_ip ? bind_ip:"auto", stun_server, repository, verbosity, port, cycle, channel, avg_pause);

	// Initialize logging

	//Init monitoring layer

	monInit(eventbase, NULL);

#include        <event2/http.h>

#include        <event2/http_struct.h>

#include	<repoclient.h>

#include	<ml.h>

	}

	/* Initialize libevent and logging */

	eventbase = event_base_new();

	repInit("");

	/* Parse config file and init repoclient with the "repository" cfg section */

	if (!ntests) fatal("No tests specified, exiting");

	struct timeval t = { 1, 0 };

	do_tests(NULL, NULL);

	repClose(repoclient);

/*

 *

 *	- or use one of the convenience macros like debug(format, args...) or info(format, args...) as shown below.

 *

 */

#include	<math.h>		/* This one is just for fun */

int main(int argc, char *argv) {

	/* Initialize logging */

	info("And here comes the %dnd, just much simpler", 2);

	error("And this is an error message");	

	info("Invisible again, as logging is closed");

	debug("Next, I'm going to fatally die...");

#include        <event2/http.h>

#include        <event2/http_struct.h>

#include	<repoclient.h>

#include	<neighborlist.h>

	}

	/* Initialize libevent and logging */

	eventbase = event_base_new();

	repInit("");

	/* Parse config file and init repoclient with the "repository" cfg section */

		cfg_getint(neighborlist_cfg, "update_period"), NULL, NULL, NULL);

	struct timeval begin = { 5, 0 };

	event_base_loop(eventbase, 0);

						evhttp_send_reply(req,305,"REQUEST PROCESSING FAILED",NULL);

						goto finally;

					}

						"<body><h3>Successfully registered to %s (delay: %f)</h3></body></html>", url, delay);

				}

				else {

					int fd = open(REGFORM_FILE_NAME,O_RDONLY);

					if(fd > 0) evbuffer_add_file(req->output_buffer, fd, 0, 10000);

						"<body><h3>Error!! Cannot load file %s</h3></body></html>", REGFORM_FILE_NAME);

				}

				evhttp_send_reply(req,200,"OK",NULL);

Peer *peer_init(const char *configfile) {

	peer = calloc(sizeof(Peer), 1);

	// Parse config file */

	cfg_t *main_config = cfg_init(cfg_main, CFGF_NONE);

	// Initialize connection opener loop for requested connections

	struct timeval begin = { 10, 0 };

	// Initialize stream source and destination

	if (!dummymode) {

	verbosity = cfg_getint(mon_config, "level");

	// Initialize logging

	info("Logging initialized with verbosity: %d", verbosity);

	// Init monitoring layer

	peer->neighborlist = neighborlist_init(peer->repository, peer->nblist_desired_size, peer->nblist_update_period, peer->channel, NULL, NULL);

	struct timeval begin = { 5, 0 };

}

// Initialize messaging layer

		receive_local_socketID_cb, (void*)eventbase);

	while (!messaging_ready) {

	}

	info("ML has been initialized, with local addess: %s", peer->LocalID);

}

	src->chunk_duration = chunk_duration;

	src->chunkid = 0;

}

// Get the list of requested connections' list from the repository

		dummymode = 1;

	}

	peer = peer_init(argv[1]);

	// Start everything

#include <event2/http_struct.h>

#include <confuse.h>

#include <ml.h>

#include <mon.h>		

#include <repoclient.h>

#include <event2/buffer.h>

#include <sys/time.h>

struct chunk {

Peer *peer_init(const char *configfile) {

	peer = calloc(sizeof(Peer),1);

	cfg_t *main_config = cfg_init(cfg_main, CFGF_NONE);

	if(cfg_parse(main_config, configfile) == CFG_PARSE_ERROR)

		recv_localsocketID_cb, eventbase);

	while (!messaging_ready) {

        }

	info("ML has been initialized, local addess is %s", LocalPeerID);

}

/*

 */

#include "chunk.h"

#include "ml.h"

/*

 */

#include	"peer.h"

		exit(-1);

	}

	info("Initialization done");

#include        <event2/http_struct.h>

#include        <confuse.h>

#include	<ml.h>

#include	<mon.h>		

#include	<repoclient.h>

	src->bev = (struct bufferevent *)bufferevent_socket_new((struct event_base *)eventbase, udpSocket, 0);

	bufferevent_enable(src->bev, EV_READ);

	src->chunk_duration = chunk_duration;

}