[Javanetsim-cvs] IceScan/icesockets crawsocket.h, NONE, 1.1 csocket.h, NONE, 1.1 sock_err.h, NONE, 1.1 sock_name.h, NONE, 1.1 sock_time.h, NONE, 1.1

[Alexander B. <da...@us...>]

Update of /cvsroot/javanetsim/IceScan/icesockets
In directory sc8-pr-cvs6.sourceforge.net:/tmp/cvs-serv7124/icesockets

Added Files:
	crawsocket.h csocket.h sock_err.h sock_name.h sock_time.h 
Log Message:


--- NEW FILE: crawsocket.h ---
#ifndef ICERAWSOCKET_H
#define ICERAWSOCKET_H

#include "csocket.h"
#include <netinet/ip.h>
#include <netinet/ip_icmp.h>

class crawsocket : csocket{
    protected:
	int protocol;

	public:
	crawsocket(int domain = PF_INET, int type = SOCK_STREAM, int protocol = NULL, int sid = -1){
	    this->domain = domain;
	    this->type = type;
		this->protocol = protocol;
	    
	    sstate = -1;
	    
	    if(sid == -1){
		this->sid = socket(domain, type, protocol);
		if(this->sid < 0) sockerror("socket");
		else sstate = 0;		    
	    }else{
	    	this->sid = sid;
	    }	    
	}	

	~crawsocket(){ }

	int set_ipheaderinclude(bool incl){
		const int on = incl ? 1 : 0;
				
		return setsockopt(IPPROTO_IP, IP_HDRINCL, &on, sizeof(on));
	}

	static unsigned short in_chksum(unsigned short *inp, int len) {
		register int nleft = len;
		register int sum = 0;
		unsigned short answer = 0;
		unsigned short *addr = inp;

		while (nleft > 1) {
			sum += *addr++;
			nleft -= 2;
		}

		if (nleft == 1) {
			*(unsigned char *)(&answer) = *(unsigned char  *)addr;
			sum += answer;
		}

		sum = (sum >> 16) + (sum & 0xffff);
		sum += (sum >> 16);
		answer = ~sum;

		return(answer);
	}

	// functions below doesn't used in raw sockets
	int connect(const char *hostname, int timeout = NULL){ }
	int accept(char *remotehost = NULL, int *remoteport = NULL){ }
	int listen(const char *hostname, int port, int size){ }
	int read(char* buf, int len, int flag = 0){ }
	int write(char* buf, int len, int flag = 0){ }
	// ^^ functions upper doesn't used in raw sockets

	int bind(const char *hostname, int port, int size){
	    struct sockaddr_in saddress;
	    int len;
	    
	    if((len == make_sockname(saddress, hostname, port, domain)))
		return sockerror("sockname");
	    
	    if(::bind(sid, (struct sockaddr *) &saddress, sizeof(struct sockaddr)) < 0)
		return sockerror("bind");
		
	    return 0;
	}	

	int setsockopt(int level, int opname, const void *optval, socklen_t optlen){
		int rc = 0;

		if( rc = ::setsockopt(sid, level, opname, optval, optlen)  > 0 )
			sockerror("setsockopt");
		
		return rc;
	}

	int sendto(char *hostname, const void *msg, int len, unsigned int flags){
		return csocket::sendto(hostname, 0, msg, len, flags);
	}

	int recvfrom(void *buf, int len, unsigned int flags, char *srchostname){
		return csocket::recvfrom(buf, len, flags, srchostname, NULL);
	}

	bool state(){
	    return (!sstate) ? true : false;
	}
	
	int get_socketid(){
	    return sid;
	}
	
	int get_domain(){
	    return domain;
	}

	int get_type(){
	    return type;
	}

	int get_protocol(){
	    return protocol;
	}
	
};

#endif 

--- NEW FILE: csocket.h ---
#ifndef CSOCKET_H
#define CSOCKET_H

#include <iostream>

#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netdb.h>
#include <cstdio>
#include <cstdlib>
#include <fcntl.h>

// Library
#include "sock_err.h"
#include "sock_name.h"
#include "sock_time.h"

class csocket{
 int cs_id;


 protected:
	int sid;
	int domain;
	int sstate;	
	int type;
	bool block;

	int sockerror(char *error){
	    perror(error);
	    sstate = -1;
	    return -1;
	}        

	const char *iptohost(const struct in_addr in) {
            u_long  laddr;

	    struct hostent *hostpointer = gethostbyaddr((char *) &laddr, sizeof(laddr), AF_INET);
	
    	if (hostpointer == NULL)
        	return 0;
    	
		for (char **p = hostpointer->h_addr_list; *p != 0; p++) {
        	(void) memcpy((char *) &in.s_addr, *p, sizeof(in.s_addr));
        	if (hostpointer->h_name)
                return hostpointer->h_name;
    	}
    	
		return 0;
	}

    
 public:
	csocket(int domain = PF_INET, int type = SOCK_STREAM, int sid = -1){
	    this->domain = domain;
	    this->type = type;
	    
		block = true;

	    sstate = -1;
	    
	    if(sid == -1){
		this->sid = socket(domain, type, 0);
		if(this->sid < 0) sockerror("socket");
		else sstate = 0;		    
	    }else{
	    	this->sid = sid;
	    }	    
		// std::cout << "CSCOCKET created." << (cs_id = rand()) << std::endl;
	}
	
	csocket(const csocket &a){
		sid = a.sid;
		domain = a.domain;
		sstate = a.sstate;	
		type =  a.type;
		block = a.block;

		// std::cout << "CSCOCKET copied: " << (a.cs_id) << " to " << (cs_id = rand()) << "." << std::endl;
	}

	int shutdown(int mode = 2){
	    sstate = 0;		
	    return ::shutdown(sid, mode);
	}

	void close(){
		::close(sid);
	}

	~csocket(){  /*std::cout << "CSCOCKET destroyed." << (cs_id) << std::endl; */ }

	

	int connect(const char *hostname, int port, int timeout = NULL){
	    struct sockaddr_in saddress;
	    int len;
	    
	    if((len == make_sockname(saddress, hostname, port, domain)))
			return sockerror("sockname");
	    
	    if(!timeout){
			if(block){
				if(::connect(sid, (struct sockaddr *) &saddress, sizeof(struct sockaddr)) < 0)
		    		return sockerror("connect");
			}else{
				 if(::connect(sid, (struct sockaddr *) &saddress, sizeof(struct sockaddr)) >= 0)
					return -1;
				 else return errno;
			}
	    }else{
                fd_set sset;
		struct timeval tv;
		
                nonblock(true);
		
		::connect(sid, (struct sockaddr *) &saddress, sizeof(struct sockaddr));

		FD_ZERO(&sset);
	        FD_SET(sid, &sset);

	        tv.tv_sec = timeout;
	        tv.tv_usec = 0;

	        int res = select(sid + 1, NULL, &sset, NULL, &tv);

		if (res < 0 && errno != EINTR){
                    nonblock(false); return ICESOCK_ERRNO;
		} else if (res == 0){
		    nonblock(false); return ICESOCK_TIMEOUT;
		} else nonblock(false);
	    }
		
	    return 0;
	}

	int listen(const char *hostname, int port, int size){
	    struct sockaddr_in saddress;
	    int len;
	    
	    if((len == make_sockname(saddress, hostname, port, domain)))
		return sockerror("sockname");
	    
	    if(::bind(sid, (struct sockaddr *) &saddress, sizeof(struct sockaddr)) < 0)
		return sockerror("bind");
		
	    if(::listen(sid, size) < 0)
		return sockerror("listen");
		
	    return 0;
	}

	int bind(const char *hostname, int port, int size){
	    struct sockaddr_in saddress;
	    int len;
	    
	    if((len == make_sockname(saddress, hostname, port, domain)))
		return sockerror("sockname");
	    
	    if(::bind(sid, (struct sockaddr *) &saddress, sizeof(struct sockaddr)) < 0)
		return sockerror("bind");
		
	    return 0;
	}

	csocket accept(char *remotehost = NULL, int *remoteport = NULL){
	    struct sockaddr_in sraddress;
	    socklen_t size = sizeof(sraddress);
	    int resultid = ::accept( sid, (struct sockaddr *) &sraddress, &size);
	    if(resultid > -1){
            if (remotehost) strcpy(remotehost, iptohost(sraddress.sin_addr));
            if (remoteport) *remoteport = ntohs(sraddress.sin_port);
			return csocket(domain, type, resultid);
	    }else return NULL;	    
	}

	int getsockopt(int level, int opname, void *optval, socklen_t *optlen){
		int rc = 0;

		if( rc = ::getsockopt(sid, level, opname, optval, optlen)  > 0 )
			sockerror("getsockopt");
		
		return rc;
	}

        int recvfrom(void *buf, int len, int flags, char *srchostname, int *srchostport){
		int rsize;
		struct sockaddr_in from;
                int fromlen;
                
		rsize = ::recvfrom(sid, buf, len, flags, (struct sockaddr *) &from, (socklen_t*) &fromlen); 

		if (srchostname) strcpy(srchostname, iptohost(from.sin_addr));
                if (srchostport) *srchostport = ntohs(from.sin_port);
                
                return rsize;
	}

	int read(char* buf, int len, int flag = 0){
	    return recv(sid, buf, len, flag);
	}

	int sendto(char *hostname, int port, const void *msg, int len, unsigned int flags){
		struct addrinfo hints, *res;
	    int salen;
		char cportbuf[8];
		char *cport = cportbuf;

		if(port == 0) cport = NULL;
		else sprintf(cport, "%d", port);
	    
		bzero(&hints, sizeof(struct addrinfo));

		hints.ai_flags = AI_CANONNAME;
		hints.ai_family = domain;
		hints.ai_socktype = type;
		
		if( getaddrinfo(hostname, cport, &hints, &res) != 0 )
			return sockerror("getaddrinfo");

		return ::sendto(sid, msg, len, flags, (const sockaddr *) res->ai_addr, res->ai_addrlen);

	}	

	int write(char* buf, int len, int flag = 0){
	    return send(sid, buf, len, flag);	
	}

	bool state(){
	    return (!sstate) ? true : false;
	}
	
	int get_socketid(){
	    return sid;
	}
	
	int get_domain(){
	    return domain;
	}

	int get_type(){
	    return type;
	}
	
	void nonblock(bool lck){
	    int arg = fcntl(sid, F_GETFL, NULL);
	    
	    if(arg < 0){ perror("Error in fcntl(.., F_GETFL, ...)."); throw "Error in fcntl(.., F_GETFL, ...)."; }
	    
	    if(lck){
			arg |= O_NONBLOCK;
			block = false;
	    }else{
			arg ^= O_NONBLOCK;		
			block = true;
		}
	
	    if( fcntl(sid, F_SETFL, arg) < 0 ){  perror("Error in fcntl(.., F_GETFL, ...).");  throw "Error in fcntl(.., F_SETFL, ...)."; }
	}
	
};

#endif 

--- NEW FILE: sock_name.h ---
#ifndef ICESOCK_SOCK_NAME_H
#define ICESOCK_SOCK_NAME_H

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pcrecpp.h>
#include <iostream>
#include <vector>

int make_sockname(struct sockaddr_in& saddr, const char *hostname, int port, int domain) {
    saddr.sin_family = domain;
    if (hostname){
        struct hostent *hostpointer = gethostbyname(hostname);
        memcpy((char *) &saddr.sin_addr, (char *) hostpointer->h_addr, hostpointer->h_length);
    } else
        saddr.sin_addr.s_addr = INADDR_ANY;


    saddr.sin_port = htons(port);
    saddr.sin_family = domain;
    memset(&(saddr.sin_zero), '\0', 8);

    return sizeof(saddr);
}


bool is_domainname(char * nisname){
    return !(pcrecpp::RE("\\d+\\.\\d+\\.\\d\\.\\d+").FullMatch(nisname));
}

short int get_ip_byhost(const char * nisname, char * retname, int retlen){
    struct hostent *h;
    char hname[1024];
    char *rname;
    
    int len = (strlen(nisname) < 1024) ? strlen(nisname) : 1024;
    
    strncpy(hname, nisname, len);
    
    if( ( h = gethostbyname(nisname) ) == NULL) {
	return -1;
    }
 	
    rname = inet_ntoa(*((struct in_addr *)h->h_addr));
 
    retlen = (retlen >= strlen(rname)) ? strlen(rname) : retlen;
    
    strncpy(retname, rname, retlen);     
    
    if(h->h_addr_list != NULL) return 1;
    else return 0;
}

short int get_ips_byhost(const char * nisname, std::vector <char *> &v){
    struct addrinfo hints, *res;
    char hname[1024];
    char *rname;
    int cnt = 0;
    
    int len = (strlen(nisname) < 1024) ? strlen(nisname) : 1024;
    
    strncpy(hname, nisname, len);

    bzero(&hints, sizeof(hints));

    hints.ai_flags = AI_CANONNAME; hints.ai_family = AF_INET; hints.ai_socktype = SOCK_STREAM;
    
    if( getaddrinfo(nisname, "domain", &hints, &res) ) {
	return -1;
    }
 	
    while(res){
        char *retname = new char [24];
        rname = inet_ntoa( *( &( ((sockaddr_in *)res->ai_addr)->sin_addr ) ) );
        int retlen = (strlen(rname) >= 24) ? strlen(rname) : 24;
        strncpy(retname, rname, retlen);     

        v.push_back(retname);
        res = res->ai_next;
        cnt++;
    }
    
    return cnt;
}

short int get_host_byip(const char * nisname, char * retname, int retlen){
    char rname[1025];
    char temp[32];
    int rc;        
    struct sockaddr_in saddr;
    struct addrinfo hints, *res;
    
    int len = make_sockname(saddr, nisname, 53, AF_INET);
    
    bzero(&hints, sizeof(hints));
    
    hints.ai_flags = AI_CANONNAME;
    hints.ai_family = AF_INET;
    
    if( (rc = getnameinfo((sockaddr *) &saddr, len, rname, 1024, temp, 32, 0)) < 0) {	
	perror("getnameinfo");	
	return -1;
    }
    
    retlen = (retlen >= strlen(rname) + 1) ? strlen(rname) + 1 : retlen;
    
    strncpy(retname, rname, retlen);     
    
    return 0;    
}

#endif 

--- NEW FILE: sock_err.h ---
#ifndef ICESOCK_ERR_H
#define ICESOCK_ERR_H

#include <errno.h>

#define ICESOCK_TIMEOUT 10  // timeout in when connecting or recieving
#define ICESOCK_PERROR -1 // socket operation error, see perror()
#define ICESOCK_ERRNO -2 // socket operation error, see ERRNO

#define ICEDEBUG 1

#define err_die(error, quiet) if(!quiet) {perror(error); exit(1);};

#define err_print(error, quiet) if(!quiet) perror(error);

#endif

--- NEW FILE: sock_time.h ---
#ifndef ICESOCK_SOCK_TIME_H
#define ICESOCK_SOCK_TIME_H

#include <time.h>

void icesleep(int secs, int nsecs){
	struct timespec ts;

    ts.tv_sec = secs;
    ts.tv_nsec = nsecs;
    nanosleep (&ts, NULL);

}
#endif