buffer.c

开源的组播程序

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <sys/socket.h>

#ifdef DMALLOC
#include "dmalloc.h"
#endif

#include "pmtp.h"

int16_t buffer_packet (struct packet_buffer *buffer,
		unsigned char *packet, uint16_t length) {
	if (buffer->size >= MAX_PACKET_BUFFER_SIZE) {
		return -1;
	}
	if ((buffer->packets[buffer->size] =
			(struct packet *) malloc (sizeof (struct packet))) == NULL) {
		fprintf (stderr, "Couldn't allocate memory for packet structure.\n");
		exit (1);
	}
	if ((buffer->packets[buffer->size]->packet =
			(unsigned char *) malloc (length)) == NULL) {
		fprintf (stderr, "Couldn't allocate memory for packet.\n");
		exit (1);
	}
	if (DEBUG & DEBUG_BUFFER_ADD)
		fprintf (stderr, "Adding %d'th packet to upload buffer\n",
			buffer->size);
	memcpy (buffer->packets[buffer->size]->packet, packet,length);
	buffer->packets[buffer->size]->length = length;
	return MAX_PACKET_BUFFER_SIZE - ++buffer->size;
}

uint16_t send_buffer (int s, struct sockaddr_in *s_in, 
		struct packet_buffer *buffer, uint32_t budget,
		uint32_t *packets, uint32_t *bytes_sent) {
	uint16_t packet_size;
	uint32_t sent = buffer->packets[0]->length;
	*packets = *bytes_sent = 0;
	while (sent < budget && buffer->size > 0) {
		packet_size = buffer->packets[0]->length;
		send_packet (s, s_in, buffer->packets[0]->packet, packet_size);
		remove_packet(buffer, 0);
		packet_size += IP_HEADER_SIZE + UDP_HEADER_SIZE;
		sent += packet_size;
		if (packets != NULL)
			*packets++;
		if (bytes_sent != NULL)
			*bytes_sent += packet_size;
		if (DEBUG & DEBUG_BUFFER_TRANSMIT)
			fprintf (stderr, "Bytes sent: %u, packet size: %u, budget: %u.\n",
				sent, packet_size, budget);
	}
	if (buffer->size <= 0)
		fprintf (stderr, "Buffer underrun for sending %d bytes.\n",
			budget - sent);
	return *bytes_sent;
}

uint16_t remove_packet (struct packet_buffer *buffer, uint16_t position) {
	int index;
	if (position >= buffer->size) {
		fprintf (stderr, "Cant remove packet buffer %d.\n", position);
		exit (1);
	}
	if (buffer->packets[position]->packet == NULL) {
		fprintf (stderr, "Packet at position %d doesn't have a payload.\n",
			position);
		exit (1);
	}
	if (buffer->packets[position] == NULL) {
		fprintf (stderr, "Packet doesn't exist in buffer at position %d.\n",
			position);
		exit (1);
	}
	if (DEBUG & DEBUG_BUFFER_REMOVE)
		fprintf (stderr, "Removing packet %u with length %u from buffer.\n",
			position, buffer->packets[position]->length);
	
	free (buffer->packets[position]->packet);
	free (buffer->packets[position]);
	for (index = position; index < buffer->size - 1; index++) {
		if (buffer->packets[index + 1] == NULL) {
			fprintf (stderr, "Null pointer found in packet_buffer array.\n");
			exit (1);
		}
		buffer->packets[index] = buffer->packets[index + 1];
	}
	buffer->packets[index] = NULL;
	return --buffer->size;
}

void send_packet (int s, struct sockaddr_in *s_in, unsigned char *packet,
		uint16_t length) {
	if (sendto (s, packet, length, 0, (struct sockaddr *) s_in,
			sizeof (struct sockaddr_in)) < 0) {
		perror ("sendto");
		exit (1);
	}
}

uint16_t init_packet_buffer (struct packet_buffer *buffer) {
	if ((buffer->packets = (struct packet **) calloc
			(MAX_PACKET_BUFFER_SIZE, sizeof (struct packet *))) == NULL) {
		fprintf (stderr, "Couldn't allocate memory for packet buffer.\n");
		exit (1);
	}
	return buffer->size = 0;
}

uint16_t free_packet_buffer (struct packet_buffer *buffer) {
	int index;
	int count = 0;
	for (index = 0; index < buffer->size; index++) {
		remove_packet (buffer, 0);
		count++;
	}
	free (buffer->packets);
	return count;
}

uint16_t buffer_packets_free (struct packet_buffer *buffer) {
	int packets_free = MAX_PACKET_BUFFER_SIZE - buffer->size;
	return packets_free > 0 ? packets_free : 0;
}