PeerStreamer

/** @file trade_msg_ha.h

 *

 * Chunk Delivery API - Higher Abstraction

 *

 * The Chunk Delivery HA provides the primitives for effective chunks exchange with other peers. <br>

 * This is a part of the Data Exchange Protocol which provides high level abstraction for sending chunks to a target peers.

 *

 * @image html SOM_Internals.png "Data Exchange Protocol of the SOM module" width=50

 */

#include "chunk.h"

/**

  * Send a Chunk to a target Peer

  *

  * Send a single Chunk to a given Peer

  *

  * @param[in] to destination peer

  * @param[in] c Chunk to send

  * @return 0 on success, <0 on error

  */

int sendChunk(struct nodeID *to, struct chunk *c);

/**

  * Init the Chunk trading stuff...

  *

  *

  * @param myID address of this peer

  * @return >= 0 on success, <0 on error

  */

int chunkInit(struct nodeID *myID);

/** 

  * Notification function for a Chunk arrival

  */

typedef int (*ChunkNotification)(struct peer *from, struct chunk  *c);

/**

  * Register a notification for Chunk arrival

  * 

  * Register a notification function that should be called at every Chunk arrival

  *

  * @param[in] som Handle to the enclosing SOM instance

  * @param[in] p notify a send of chunk from Peer p, or from any peer if NULL

  * @param[in] fn pointer to the notification function.

  * @return a handle to the notification or NULL on error @see unregisterSendChunk

  */

void registerSendChunkNotifier(struct peer *p, ChunkNotification *fn);

/*

 *  Copyright (c) 2009 Alessandro Russo.

 *

 *  This is free software;

 *  see GPL.txt

 */

 //header to clean

#include <stdio.h>

#include <stdlib.h>

#include <stdint.h>

#include "chunk.h"

#include "net_helper.h"

#include "trade_msg_la.h"

#include "trade_msg_ha.h"

static struct nodeID *localID;

static void chunk_print(FILE *f, const struct chunk *c)

{

  const uint8_t *p;

  fprintf(f, "Chunk %d:\n", c->id);

  fprintf(f, "\tTS: %llu\n", c->timestamp);

  fprintf(f, "\tPayload size: %d\n", c->size);

  fprintf(f, "\tAttributes size: %d\n", c->attributes_size);

  p = c->data;

  fprintf(f, "\tPayload:\n");

  fprintf(f, "\t\t%c %c %c %c ...:\n", p[0], p[1], p[2], p[3]);

  if (c->attributes_size > 0) {

    p = c->attributes;

    fprintf(f, "\tAttributes:\n");

    fprintf(f, "\t\t%c %c %c %c ...:\n", p[0], p[1], p[2], p[3]);

  }

}

/**

 * Send a Chunk to a target Peer

 *

 * Send a single Chunk to a given Peer

 *

 * @param[in] to destination peer

 * @param[in] c Chunk to send

 * @return 0 on success, <0 on error

 */

//TO CHECK AND CORRECT

//XXX Send data is in char while our buffer is in uint8

int sendChunk(struct nodeID *to, struct chunk *c){

    int buff_len;

    uint8_t *buff;

    int res;

    buff_len  = 20 + c->size + c->attributes_size;

    buff = malloc(buff_len + 1);

    if (buff == NULL) {

        return -1;

    }

    res = encodeChunk(c, buff + 1, buff_len);

    fprintf(stdout, "Encoding chunk %d in %d bytes\n",res, buff_len);

    chunk_print(stdout, c);

    buff[0] = 12;

    send_data(localID, to, buff, buff_len + 1);

    free(buff);

    return (EXIT_SUCCESS);

}

int chunkInit(struct nodeID *myID)

{

  localID = myID;

  return 1;

}