mysock.cpp

典型的udp传输类

/*

 * mysock.c            (c) Wang yajun           25/9/2000

 *

 * Socket class Implemented for VOD server

 *

 * Description:

 *  create BSD-compatible socket, include Multicast APIs

 *  send one multicast or cast messages in response a call for send()  

 *  receive one messages and link to up layer receive funtions

 */

#ifdef WIN32

#include <stdio.h>

#include <winsock2.h>

#include <ws2tcpip.h>

#define socklen_t	int

#else

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <errno.h>



#define closesocket(s)  close(s)

#endif



#include "mysock.h"



#define FALSE 0

#define TRUE  1

#define TTL_VALUE 255



mySock::mySock()

{

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

    m_nSockType = 0;

    m_sock      = 0;

    m_multicast = 0;

}



mySock::~mySock()

{

    if ( m_sock ) closesocket(m_sock);

}



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

 * Name : Create

 * Func : create a datagram socket

 * Param: remote+rport

 *        local+lport

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



int mySock::Create(char *remote, int rport, char *local, int lport, int nType )

{

/*

    (1) check param valid

        remote, local, rport, lport, nType

        fill every sock_addr and chekc multicast flag

    (2)create socket(datagram)

    (3)setsockopt and bind

    (4)if multicast then setsockopt(multicast)

*/

    int multicast=0, n=0, ret=0, on=1;

    int s;

    struct sockaddr_in stLocal, stRemote;

    char *tempaddr, strRemote[256], strLocal[256];

    /* check port */

    if ( rport<0 || rport >9999 || lport <0 || lport >9999 ) {

    	printf("Invalid port value\n");

    	return FALSE;

    } 

    if ( !(nType & S_WYJ_SEND) && !(nType & S_WYJ_RECV) ) {

        printf("Invalid nType value\n");

        return FALSE;

    }

    strcpy(strRemote, remote);

    strcpy(strLocal, local);

    /* check multicast */

    tempaddr = strchr(strRemote, '.');

    if ( tempaddr==NULL ) return FALSE;

    tempaddr[0] = '\0';

    n = atoi(strRemote);

    if ( n <=0 || n>=255 ) {

    	printf("Invalid address");

    }

    if ( n>=224 ) multicast = 1;

    tempaddr[0] = '.';

   

    /* get a datagram or stream socket */

    s = socket(AF_INET, SOCK_DGRAM, 0);

    if (s < 0) {

    	printf ("socket() failed, Err: %d\n", errno);

        return FALSE;

    }

    /* avoid EADDRINUSE error on bind() */ 

    ret = setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on));

    if (ret < 0 ) {

        printf ("setsockopt() SO_REUSEADDR failed, Err: %d\n", errno);

        closesocket(s);

        return FALSE;

    }

    if ( nType & S_WYJ_RECV ) {

		stLocal.sin_family = AF_INET;

		stLocal.sin_addr.s_addr = inet_addr(strLocal);

		stLocal.sin_port = htons(rport);

#ifndef WIN32

		if (multicast) 

		    stLocal.sin_addr.s_addr = inet_addr(strRemote);

#endif

        ret = bind(s, (struct sockaddr*)&stLocal, sizeof(stLocal));

        if ( ret < 0 ) {

            printf ("bind() failed, Err: %d\n", errno );

            closesocket(s);

            return FALSE;

        }

    }

	else if( nType&S_WYJ_SEND ) {

		stLocal.sin_family = AF_INET;

		stLocal.sin_addr.s_addr = inet_addr(strLocal);

		stLocal.sin_port = htons(lport);



        ret = bind(s, (struct sockaddr*)&stLocal, sizeof(stLocal));

        if ( ret < 0 ) {

            printf ("bind() failed, Err: %d\n", errno );

            closesocket(s);

            return FALSE;

        }

    }



	/* name the socket */

    stLocal.sin_family = AF_INET;

    stLocal.sin_addr.s_addr = inet_addr(strLocal);

    stLocal.sin_port = htons(lport);

    stRemote.sin_family = AF_INET;

    stRemote.sin_addr.s_addr = inet_addr(strRemote);

    stRemote.sin_port = htons(rport);



    if ( multicast ) {

	struct ip_mreq stMreq;

	/* join the multicast group. */

	  	stMreq.imr_multiaddr.s_addr = inet_addr(strRemote);

        stMreq.imr_interface.s_addr = inet_addr(strLocal);

        ret = setsockopt(s, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *)&stMreq, sizeof(stMreq));

        if ( ret < 0 ) {

            printf ("setsockopt() IP_ADD_MEMBERSHIP failed, Err: %d\n",errno);

            closesocket(s);

            return FALSE;

        } 

        /* set TTL to traverse up to multiple routers */

        on = TTL_VALUE;

        ret = setsockopt(s, IPPROTO_IP, IP_MULTICAST_TTL, (char *)&on, sizeof(on));

        if ( ret < 0 ) {

            printf ("setsockopt() IP_MULTICAST_TTL failed, Err: %d\n", errno);

            closesocket(s);

            return FALSE;

        }

        /* disable loopback */

        on  = TRUE;

        ret = setsockopt(s, IPPROTO_IP, IP_MULTICAST_LOOP, (char *)&on, sizeof(on));

        if ( ret < 0 ) {

            printf ("setsockopt() IP_MULTICAST_LOOP failed, Err: %d\n",errno);

        }

    }

    if ( m_sock ) closesocket(m_sock);

    m_sock = s;

    m_multicast = 0;

    	

    memcpy(&m_remote, &stRemote,sizeof(stRemote));

    m_nSockType = nType;

    return TRUE;

}



void mySock::Close()

{

    if ( m_sock ) {

    	closesocket(m_sock);

        m_sock = 0;

    }

}



int mySock::SendMsg(char *pbuffer, int length)

{

    int ret;

    ret = sendto( m_sock, pbuffer, length,

          0, (struct sockaddr*)&m_remote, sizeof(m_remote) );

    if (ret < 0) {

        printf ("sendto() failed, Error: %d\n", errno);

        return FALSE;

    }

    return TRUE;

}



int mySock::RecvMsg(char *pbuffer, int length)

{

    int ret;

    socklen_t addr_len;

    struct sockaddr_in stFrom;

	addr_len=sizeof(stFrom);

    ret = recvfrom( m_sock, pbuffer, length, 

          0, (struct sockaddr*)&stFrom, (socklen_t*)&addr_len );

    if (ret < 0) {

        printf ("recvfrom () failed, Error: %d\n", errno );

    }

/*

    else if ( addr_len>0 ) {

    	printf("From host:%s port:%d, length:%d\n", inet_ntoa(stFrom.sin_addr), 

          	ntohs(stFrom.sin_port), ret);

    }

*/

    return ret;

}