olfile.cpp

socket文件传输源码

                                  
/**
	Offload file transfer module using socket to test TCP offload engine(TOE).
	By Vino @ 9th, June 2004.
	Email: [e-mail]
	All copyrights reserved.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#ifdef WIN32
	#include <io.h>
	#include <winsock2.h>
#else
	#include <sys/socket.h>
	#include <sys/un.h>
	#include <unistd.h>
	#include <netinet/in.h>
	#include <arpa/inet.h>
#endif
#include <time.h>

#include "olfile.h"

const char str_usg[] = 
	"\nTransfer a file from data source to data sink through network.\n\n"
	"  olfile -src sourcefile -snk sinkfile -ip dotip [-y]\n"
	"     Copy sourcefile on local to sinkfile on ip dotip.\n\n"
	"  olfile -snk sinkfile -src sourcefile -ip dotip [-y]\n"
	"     Copy sourcefile on ip dotip to sinkfile on local.\n\n"
	"  olfile -server\n"
	"     Start olfile service.\n\n"
	"Options:\n"
	"    -src + sourcefile      Data source file full path\n"
	"    -snk + sinkfile        Data sink file full path\n"
	"    -ip  + dotip           Dot divided ip address\n"
	"    -y                     Default to delete exists file.\n\n"
	"Example:\n"
	"     -snk f:/data.txt -src f:/datarcv.txt -ip 10.190.5.179 -y\n\n"
	"By Vino.Cui @ 9th, June 2004 from Inventec.\n"
	"Revision:\n"
	"1. 13th, June 2004 Completed the original version: Transfering file \nfrom data source to data sink via ip specified by -ip argument. \n";

const size_t OP_HEAD_SIZE = sizeof(struct st_op_head);
struct st_reg_sem s_reg_sem;
/** these 4 buffer pools are dynamic allocated in the program.
  file -> read-File Buffer Pool -> send-NIC Buffer Pool -> NIC
  file <- write-File Buffer Pool <- receive-NIC Buffer Pool <- NIC
but this implementation needs buffer copy(copy read-file Buffer to send-NIC Buffer pool and back-forth).
  char *rdFileBufPool, *wrFileBufPool;
  char *sendNicBufPool, *recvNicBufPool;
*/
char *lanin_buf, *lanout_buf;
char *gfin_buf, *gfout_buf;
float ftop_spd = 0.0; // top speed, bytes/s
/***/

int
init_socket()
{
#ifdef WIN32
	WSADATA wsaData;
	int iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
	if (iResult != NO_ERROR)
	{
		printf("Error at WSAStartup()\n");
		return -1;
	}
	return 0;
#else
	return 0;
#endif
}

int
create_conn(){
	SOCKET s;
	struct sockaddr_in local;
	BOOL bOptVal = TRUE;
	int bOptLen = sizeof(BOOL);
	int iOptLen = sizeof(int);

	if((s = socket(AF_INET_NORMAL, SOCK_STREAM, 0)) == -1){
		perror("socket");
		return -1;
	}

	int a= setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char*)&bOptVal, bOptLen);

	memset(&(local), 0, sizeof(struct sockaddr_in));

	local.sin_family = AF_INET;      /* host byte order */
	local.sin_port = htons(SERVER_PORT);
	local.sin_addr.s_addr = INADDR_ANY;
	if ( -1 == bind(s, (struct sockaddr*)&local, sizeof(struct sockaddr)) )
	{
		fprintf(stderr, "bind error\n");
		show_err();
		return (-1);
	}
	
	if ( -1 == listen(s, 5)) {
		fprintf(stderr, "Listening error.");
		show_err();
		return (-1);
	}

	return s;	
}

// create a connection with the remote peer
int open_conn(char *str_ip){
	SOCKET s;
	struct sockaddr_in local, remote;
	int ret = 0;
	BOOL bOptVal = TRUE;
	int bOptLen = sizeof(BOOL);
	int iOptLen = sizeof(int);

	if (NULL == str_ip) {
		fprintf(stderr, "No destination IP!\n");
		return (-1);
	}

	if((s = socket(AF_INET, SOCK_STREAM, 0)) == -1){
		perror("socket");
		return -1;
	}

	int a=setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char*)&bOptVal, bOptLen);

	memset(&(local), 0, sizeof(struct sockaddr_in));

//	local.sin_family = AF_INET;
//	local.sin_port = htons(CLIENT_PORT);
//	local.sin_addr.s_addr = INADDR_ANY;
//	if ( -1 == bind(s, (struct sockaddr*)&local, sizeof(struct sockaddr)) )
	{
//		fprintf(stderr, "bind error\n");
//		show_err();
//		return (-1);
	}


	memset(&(remote), 0, sizeof(struct sockaddr_in));
	remote.sin_family = AF_INET;
	remote.sin_port = htons(SERVER_PORT);
	remote.sin_addr.s_addr = inet_addr(str_ip);

	fprintf(stderr, "Connecting to %s\n\n", str_ip);

	int retry = 10;
	do {
		if (-1 == (ret = connect(s, (struct sockaddr *)&remote, sizeof(struct sockaddr)))) {
	#ifdef WIN32
			show_err();
	#endif
			fprintf(stderr, "Connect error. Retry %d times\r", 11-retry);
			retry--;
#ifdef WIN32
			Sleep(1000);
#else
			sleep(1);
#endif
			if (retry == 0) {
				return -1;
			}
		}
	} while( -1 == ret );

	fprintf(stderr, "\n");
	return s;
}

// close the connection with the daemon
void close_conn(int sfd){
#ifdef WIN32
	closesocket(sfd);
	WSACleanup();
	fprintf(stderr, "Connection context released.\n");
#else
	close(sfd);
#endif
}

// Give the head and the message buffer buf, 
// send the `big buffer'
// +-----------+----------------------+
// |  head     |      buffer          |
// +-----------+----------------------+
// send_ptocol_buf

// receive the head and the message buf: head, buf
// recv_ptocol_buf
// send a request with the type: 
// send_request
// receive_reply
// receive_result

// server functions:
// response to client function: send_request
// receive_request
// response to client function: receive_reply
// send_reply
// responst to client function: receive_result 
// send_result

struct st_con_arg*
parse_arg(int argc, char** argv){
	char **pargv = argv;
	size_t len;
	struct st_con_arg *s_con = new struct st_con_arg;
	int i;

	memset(s_con, 0, sizeof(struct st_con_arg));
	s_con->flag = 1; // make valid
	//	"olfile -src sourcefile -sink ip/sinkfile [-y]\n"
	if (argc < 7) {
		if (argc == 2) {
			// maybe service mode
			s_con->flag = 1;
		}
		else
		{
			s_con->flag = 0; // make valid
		}
	}

	for ( i=0, s_con->str_ip = NULL; i<argc-1 && s_con->flag!=0; i++)
	{
		pargv++;
		if (0 == memcmp(*pargv, ARG_SRV, sizeof(ARG_SRV))) {
			s_con->peer_mode = SERVER;
			continue;
		}
		else{
			if (argc == 2) {
				// only -server has 1 argument.
				s_con->flag = 0;
				continue;
			}
			s_con->peer_mode = CLIENT;
			// must not continue;
		}

		if (0 == memcmp(*pargv, ARG_SNK, sizeof(ARG_SNK))) 
		{
			if (0 < s_con->sink_addr.pathlen) {
				// the -snk has been specified, no src available
				fprintf(stderr, "No -src available.\n");
				s_con->flag = 0;
			}

			if ( DATA_SRC != s_con->con_mode) {
				s_con->con_mode = DATA_SNK;
			}
			
			pargv++; i++;
			len = strlen(*pargv);
			s_con->sink_addr.ppath = new char[len + 1];
			memcpy(s_con->sink_addr.ppath, *pargv, len);
			s_con->sink_addr.ppath[len] = 0;
			s_con->sink_addr.pathlen = len;
		}
		else if (0 == memcmp(*pargv, ARG_SRC, sizeof(ARG_SRC))) 
		{
			if (0 < s_con->src_addr.pathlen) {
				// the -snk has been specified, no src available
				fprintf(stderr, "No -snk available.\n");
				s_con->flag = 0;
			}

			if ( DATA_SNK != s_con->con_mode) {
				s_con->con_mode = DATA_SRC;
			}

			pargv++; i++;
			len = strlen(*pargv);
			s_con->src_addr.ppath = new char[len + 1];
			memcpy(s_con->src_addr.ppath, *pargv, len);
			s_con->src_addr.ppath[len] = 0;
			s_con->src_addr.pathlen = len;
		}
		else if (0 == memcmp(*pargv, ARG_IP, sizeof(ARG_IP))) 
		{
			pargv++; i++;
			len = strlen(*pargv);
			s_con->str_ip = new char[len+1];
			memcpy(s_con->str_ip, *pargv, len);
			s_con->str_ip[len] = 0;
		}
		else if (0 == memcmp(*pargv, ARG_Y, sizeof(ARG_Y))) {
			s_con->cfm_mode = OVERIDE;
		}
		else if (0 == memcmp(*pargv, ARG_MAGGIE, sizeof(ARG_MAGGIE))) {
			s_con->flag = 0;
			fprintf(stderr, "--< Hello , Maggy !>--\n");
		}
		else
		{
			s_con->flag = 0;
		}
	}

	if (s_con->sink_addr.pathlen == 0 || s_con->src_addr.pathlen == 0) {
		if (s_con->peer_mode == SERVER) {
			s_con->flag = 1;
		}
		else
		{
			s_con->flag = 0;
		}
	}

	return s_con;
}


time_t t_start; // starting time
int main(int argc, char** argv)
{
	struct st_con_arg *s_con_arg;
	unsigned int s;		// original socket fd
	int ret = 0;

	time_t t_end, t_interval;
	time_t t_hou, t_min, t_sec;

	t_start = time(&t_start);

	lanin_buf = new char [MAX_MSG_LEN + OP_HEAD_SIZE + 1];
	lanout_buf = new char [MAX_MSG_LEN + OP_HEAD_SIZE + 1];
	
	if (NULL == lanin_buf || NULL == lanout_buf) {
		fprintf(stderr, "Low memory to alloc lan buffer.\n");
		return -1;
	}
	
	gfin_buf = new char [FILE_BUF_LEN + 1];
	gfout_buf = new char [FILE_BUF_LEN + 1];
	if ( NULL == gfin_buf || NULL == gfout_buf ) {
		fprintf(stderr, "Low memory to alloc file buffer.\n");
		return -1;
	}

	s_con_arg = parse_arg(argc, argv);
	if (s_con_arg->flag == 0) {
		printf(str_usg);
		delete s_con_arg;
		return -1;
	}

	init_socket();

	if (s_con_arg->peer_mode == SERVER) {
		// entered service mode
		if (-1 == (s = create_conn())) {
			delete s_con_arg;
			return -1;
		}

		unsigned int ns; // new socket fd.
		struct sockaddr remote;
		int len;
		len = sizeof(struct sockaddr);

		// Listening ...
		fprintf(stderr, "%s\n", "Listening...");
		ns = accept(s, (struct sockaddr *)&remote, (socklen_t *)&len);
		
		// make a new thread here.
		// folk();
		struct sockaddr_in *si = (struct sockaddr_in *)&remote;
//	remote.sin_addr.s_addr = inet_addr(str_ip);

		fprintf(stderr, "Client connected from %s.\n", inet_ntoa(si->sin_addr));
		
		// Connection attemption accepted..