network4.c

Go to the documentation of this file.

 
#include "network.h"
#include <time.h>
 
 
int  udp_server_socket(int port) 
{
    int  sofd, err;
    struct sockaddr_in sv_addr;
 
    sofd = (int)socket(AF_INET, SOCK_DGRAM, 0);
    if (sofd<0) return -1;
 
    memset(&sv_addr, 0, sizeof(sv_addr));
    sv_addr.sin_family = AF_INET;
    sv_addr.sin_port   = htons(port);
    sv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
 
    // TIME_WAIT しない設定．
/*    struct linger lg;
    lg.l_onoff  = 1;
    lg.l_linger = 0;
    err = setsockopt(sofd, SOL_SOCKET, SO_LINGER, &lg, sizeof(lg));
    if (err<0) {
        socket_close(sofd);
        return -2;
    } 
*/
    err = bind(sofd, (struct sockaddr*)&sv_addr, sizeof(sv_addr));
    if (err<0) {
        socket_close(sofd);
        return -3;
    }
 
    return sofd;
}
 
 
int  udp_server_socket_setopt(int port, int opt, const void* optval, int optlen) 
{
    int  sofd, err;
    struct sockaddr_in sv_addr;
 
    sofd = (int)socket(AF_INET, SOCK_DGRAM, 0);
    if (sofd<0) return -1;
 
    memset(&sv_addr, 0, sizeof(sv_addr));
    sv_addr.sin_family = AF_INET;
    sv_addr.sin_port   = htons(port);
    sv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
 
    if (opt>0) {
        #ifdef WIN32
            err = setsockopt(sofd, SOL_SOCKET, opt, (const char*)optval, optlen);
        #else
            err = setsockopt(sofd, SOL_SOCKET, opt, optval, optlen);
        #endif
        if (err<0) {
            socket_close(sofd);
            return -2;
        } 
    }
 
    err = bind(sofd, (struct sockaddr*)&sv_addr, sizeof(sv_addr));
    if (err<0) {
        socket_close(sofd);
        return -3;
    }
 
    return sofd;
}
 
 
int  udp_client_socket(char* hostname, int port, struct sockaddr_in* sv_addr)
{
    int  sofd;
    struct hostent* shost;
 
    sofd = (int)socket(AF_INET, SOCK_DGRAM, 0);
    if (sofd<0) return -1;
 
    shost = gethostbyname(hostname); 
    if (shost==NULL) {
        socket_close(sofd);
        return -4
    }
 
    memset(sv_addr, 0, sizeof(*sv_addr));
    sv_addr->sin_family = AF_INET;
    sv_addr->sin_port   = htons(port);
    memcpy(&(sv_addr->sin_addr), shost->h_addr, shost->h_length);
   
    return sofd;
}
 
 
int  udp_bind(int sofd, int port) 
{
    int  err;
    struct sockaddr_in sv_addr;
 
    if (sofd<=0) return sofd;
 
    memset(&sv_addr, 0, sizeof(sv_addr));
    sv_addr.sin_family = AF_INET;
    sv_addr.sin_port   = htons(port);
    sv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
 
    err = bind(sofd, (struct sockaddr*)&sv_addr, sizeof(sv_addr));
    if (err<0) {
        socket_close(sofd);
        return -3;
    }
 
    return sofd;
}
 
 
int  udp_bind_setopt(int sofd, int port, int opt, const void* optval, int optlen) 
{
    int  err;
    struct sockaddr_in sv_addr;
 
    if (sofd<=0) return sofd;
 
    memset(&sv_addr, 0, sizeof(sv_addr));
    sv_addr.sin_family = AF_INET;
    sv_addr.sin_port   = htons(port);
    sv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
 
    if (opt>0) {
        #ifdef WIN32
            err = setsockopt(sofd, SOL_SOCKET, opt, (const char*)optval, optlen);
        #else
            err = setsockopt(sofd, SOL_SOCKET, opt, optval, optlen);
        #endif
        if (err<0) {
            socket_close(sofd);
            return -2;
        } 
    }
 
    err = bind(sofd, (struct sockaddr*)&sv_addr, sizeof(sv_addr));
    if (err<0) {
        socket_close(sofd);
        return -3;
    }
 
    return sofd;
}
 
 
int  tcp_server_socket(int port) 
{
    int  sofd, err;
    struct sockaddr_in sv_addr;
 
    sofd = (int)socket(AF_INET, SOCK_STREAM, 0);
    if (sofd<0) return -1;
 
    memset(&sv_addr, 0, sizeof(sv_addr));
    sv_addr.sin_family = AF_INET;
    sv_addr.sin_port   = htons(port);
    sv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
 
    err = bind(sofd, (struct sockaddr*)&sv_addr, sizeof(sv_addr));
    if (err<0) {
        socket_close(sofd);
        return -3;
    }
 
    err = listen(sofd, 10);
    if (err==-1) {
        socket_close(sofd);
        return -6;
    }
 
    return sofd;
}
 
 
int  tcp_server_socket_setopt(int port, int opt, const void* optval, int optlen) 
{
    int  sofd, err;
    struct sockaddr_in sv_addr;
 
    sofd = (int)socket(AF_INET, SOCK_STREAM, 0);
    if (sofd<0) return -1;
 
    memset(&sv_addr, 0, sizeof(sv_addr));
    sv_addr.sin_family = AF_INET;
    sv_addr.sin_port   = htons(port);
    sv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
 
    if (opt>0) {
        #ifdef WIN32
            err = setsockopt(sofd, SOL_SOCKET, opt, (const char*)optval, optlen);
        #else
            err = setsockopt(sofd, SOL_SOCKET, opt, optval, optlen);
        #endif
        if (err<0) {
            socket_close(sofd);
            return -2;
        }
    }
 
    err = bind(sofd, (struct sockaddr*)&sv_addr, sizeof(sv_addr));
    if (err<0) {
        socket_close(sofd);
        return -3;
    }
 
    err = listen(sofd, 10);
    if (err==-1) {
        socket_close(sofd);
        return -6;
    }
 
    return sofd;
}
 
 
int  tcp_server_bind(int port) 
{
    int  sofd, err;
    struct sockaddr_in sv_addr;
 
    sofd = (int)socket(AF_INET, SOCK_STREAM, 0);
    if (sofd<0) return -1;
 
    memset(&sv_addr, 0, sizeof(sv_addr));
    sv_addr.sin_family = AF_INET;
    sv_addr.sin_port   = htons(port);
    sv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
 
    err = bind(sofd, (struct sockaddr*)&sv_addr, sizeof(sv_addr));
    if (err<0) {
        socket_close(sofd);
        return -3;
    }
 
    return sofd;
}
 
 
int  tcp_server_bind_setopt(int port, int opt, const void* optval, int optlen) 
{
    int  sofd, err;
    struct sockaddr_in sv_addr;
 
    sofd = (int)socket(AF_INET, SOCK_STREAM, 0);
    if (sofd<0) return -1;
 
    if (opt>0) {
        #ifdef WIN32
            err = setsockopt(sofd, SOL_SOCKET, opt, (const char*)optval, optlen);
        #else
            err = setsockopt(sofd, SOL_SOCKET, opt, optval, optlen);
        #endif
        if (err<0) {
            socket_close(sofd);
            return -2;
        }
    }
 
    memset(&sv_addr, 0, sizeof(sv_addr));
    sv_addr.sin_family = AF_INET;
    sv_addr.sin_port   = htons(port);
    sv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
 
    err = bind(sofd, (struct sockaddr*)&sv_addr, sizeof(sv_addr));
    if (err<0) {
        socket_close(sofd);
        return -3;
    }
 
    return sofd;
}
 
 
int  tcp_client_socket(char* hostname, int port) 
{
    int sofd, err;
    struct hostent     *shost;
    struct sockaddr_in sv_addr;
 
    sofd = (int)socket(AF_INET, SOCK_STREAM, 0);
    if (sofd<0) return -1;
 
    shost = gethostbyname(hostname); 
    if (shost==NULL) {
        socket_close(sofd);
        return -4;
    }
 
    memset(&sv_addr, 0, sizeof(sv_addr));
    sv_addr.sin_family = AF_INET;
    sv_addr.sin_port   = htons(port);
    memcpy(&sv_addr.sin_addr, shost->h_addr, shost->h_length);
 
    err = connect(sofd, (struct sockaddr*)&sv_addr, sizeof(sv_addr));
    if (err<0) {
        socket_close(sofd);
        return -5;
    }
 
    return sofd;
}
 
 
int  tcp_client_bind_socket(char* hostname, int sport, int cport)  
{
    int sofd, err;
    struct hostent  *shost;
    struct sockaddr_in sv_addr;
 
    sofd = (int)socket(AF_INET, SOCK_STREAM, 0);
    if (sofd<0) return -1;
 
    memset(&sv_addr, 0, sizeof(sv_addr));
    sv_addr.sin_family = AF_INET;
    sv_addr.sin_port   = htons(cport);
    sv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
 
    err = bind(sofd, (struct sockaddr*)&sv_addr, sizeof(sv_addr));
    if (err<0) {
        socket_close(sofd);
        return -3;
    }
 
    shost = gethostbyname(hostname); 
    if (shost==NULL) {
        socket_close(sofd);
        return -4;
    }
 
    memset(&sv_addr, 0, sizeof(sv_addr));
    sv_addr.sin_family = AF_INET;
    sv_addr.sin_port   = htons(sport);
    memcpy(&sv_addr.sin_addr, shost->h_addr, shost->h_length);
 
    err = connect(sofd, (struct sockaddr*)&sv_addr, sizeof(sv_addr));
    if (err<0) {
        socket_close(sofd);
        return -5;
    }
 
    return sofd;
}
 
 
int  tcp_bind(int sofd, int port)  
{
    int  err;
    struct sockaddr_in sv_addr;
 
    if (sofd<=0) return sofd;
 
    memset(&sv_addr, 0, sizeof(sv_addr));
    sv_addr.sin_family = AF_INET;
    sv_addr.sin_port   = htons(port);
    sv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
 
    err = bind(sofd, (struct sockaddr*)&sv_addr, sizeof(sv_addr));
    if (err<0) {
        socket_close(sofd);
        return -3;
    }
 
    return sofd;
}
 
 
int  tcp_bind_setopt(int sofd, int port, int opt, const void* optval, int optlen)  
{
    int  err;
    struct sockaddr_in sv_addr;
 
    if (sofd<=0) return sofd;
 
    if (opt>0) {
        #ifdef WIN32
            err = setsockopt(sofd, SOL_SOCKET, opt, (const char*)optval, optlen);
        #else
            err = setsockopt(sofd, SOL_SOCKET, opt, optval, optlen);
        #endif
        if (err<0) {
            socket_close(sofd);
            return -2;
        } 
    }
 
    memset(&sv_addr, 0, sizeof(sv_addr));
    sv_addr.sin_family = AF_INET;
    sv_addr.sin_port   = htons(port);
    sv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
 
    err = bind(sofd, (struct sockaddr*)&sv_addr, sizeof(sv_addr));
    if (err<0) {
        socket_close(sofd);
        return -3;
    }
 
    return sofd;
}
 
 
int accept_intr(int sock, struct sockaddr* cl_addr, socklen_t* cdlen)
{
    int nsofd = 0;
 
    do {
        nsofd = (int)accept(sock, cl_addr, cdlen);
    } while (nsofd==-1 && errno==EINTR);
 
    //if (nsofd<0) Error("accept_intr");
 
    return nsofd;
}
 
 
/*
int  tcp_connect(int sofd, char* hostname, int port)
 
TCPのクライアントソケットを通して，サーバに接続する．
 
この関数内で呼び出される関数: gethostbyname(), connect()
 
@param  sofd      ソケット記述子
@param  hostname  サーバ名
@param  port      サーバポート番号
 
@retval  0  成功
@retval -4  サーバ情報の取得に失敗．
@retval -5  サーバへの接続に失敗．
 */
int  tcp_connect(int sofd, char* hostname, int port) 
{
    int  err;
    struct hostent  *shost;
    struct sockaddr_in sv_addr;
 
    shost = gethostbyname(hostname); 
    if (shost==NULL) return -4;
 
    memset(&sv_addr, 0, sizeof(sv_addr));
    sv_addr.sin_family = AF_INET;
    sv_addr.sin_port   = htons(port);
    memcpy(&sv_addr.sin_addr, shost->h_addr, shost->h_length);
 
    err = connect(sofd, (struct sockaddr*)&sv_addr, sizeof(sv_addr));
    if (err<0) return -5;
    return 0;
}
 
 
int  socket_close(int sofd)
{
    int  err = -1;
 
    if (sofd>0) {
        #ifdef WIN32
            err = shutdown(sofd, 2);
            closesocket(sofd);
        #else
            err = shutdown(sofd, SHUT_RDWR);
            close(sofd);
        #endif
    }
    return err;
}
 
 
 
//
//
//
 
int  udp_recv(int sock, char* rmsg, int size, struct sockaddr_in* sv_addr)
{
    int cc;
     socklen_t cadlen;
 
    cadlen = sizeof(*sv_addr);
    memset(rmsg, 0, size);
    cc = recvfrom(sock, rmsg, size, 0, (struct sockaddr*)sv_addr, &cadlen);
 
    return cc;
}
 
 
int  udp_send(int sock, char* smsg, int size, struct sockaddr_in* sv_addr)
{
    int cc;
 
    if (size<=0) size = (int)strlen(smsg);
//    hton_ar(smsg, size);
    cc = sendto(sock, smsg, size, 0, (struct sockaddr*)sv_addr, sizeof(*sv_addr));
 
    return cc;
}
 
 
int  tcp_recv(int sock, char* rmsg, int size)
{
    int cc;
 
    memset(rmsg, 0, size);
    cc = recv(sock, rmsg, size, 0);
 
    return cc;
}
 
 
int  tcp_send(int sock, char* smsg, int size)
{
    int cc;
 
    if (size<=0) size = (int)strlen(smsg);
    cc = send(sock, smsg, size, 0);
 
    return cc;
}
 
 
int  udp_recv_wait(int sock, char* rmsg, int size, struct sockaddr_in* sv_addr, int tm)
{
    int  cc;
 
    if (recv_wait(sock, tm)) {
        cc = udp_recv(sock, rmsg, size, sv_addr); 
    }
    else {
        return RECV_TIMEOUTED;
    }
    return cc;
}
 
 
int  tcp_recv_wait(int sock, char* mesg, int sz, int tm)
{
    int  cc;
 
    if (recv_wait(sock, tm)) {
        cc = recv(sock, mesg, sz, 0); 
    }
    else {
        return RECV_TIMEOUTED;
    }
    return cc;
}
 
 
int  tcp_send_mesgln(int sock, char* mesg)
{
    int   cc, sz;
    char* buf;
 
    sz = (int)strlen(mesg) + 3;    /* CR+LF+0x00 */
    buf = (char*)malloc(sz);
    if (buf==NULL) return -1;
 
    strncpy(buf, mesg, sz);
    strncat(buf, "\r\n", 2);
//    hton_ar(buf, strlen(buf));
    cc = send(sock, buf, (int)strlen(buf), 0);
 
    free(buf);
    return cc;
}
 
 
int  tcp_recv_mstream(int sock, char* mesg, int sz, mstream* sb, int tm)
{
    int  cc;
    unsigned char* pp;
 
    if (mesg==NULL || sb==NULL) return -2;
    memset(mesg, 0, sz);
 
    if (sb->buf==NULL) {
        *sb = make_mstream(RECVBUFSZ);
        if (sb->buf==NULL) return -3;
    }
 
    while (sb->datano==0) {
        cc = tcp_recv_wait(sock, mesg, sz, tm);
        if (cc<=0) return cc;
        put_mstream(sb, (unsigned char*)mesg);
        memset(mesg, 0, sz);
    }
 
    pp = get_mstream(sb);
    if (pp==NULL) return -4;
    if (strlen((const char*)pp)>=(unsigned int)sz) {
        memcpy(mesg, pp, sz-1);
        free(pp);
        return -5;
    }
    memcpy(mesg, pp, strlen((const char*)pp));
 
    free(pp);
    return (int)strlen(mesg);
}
 
 
 
//
// アドレス処理
//
 
char*  get_hostname_bynum(unsigned char* num) 
{
    int   len;
    char* hname;
    struct hostent* hent;
 
    #ifdef WIN32
        hent = gethostbyaddr((const char*)num, 4, AF_INET);
    #else
        hent = gethostbyaddr(num, 4, AF_INET);
    #endif
    
    if (hent==NULL) return NULL;
 
    len = (int)strlen(hent->h_name);
    hname = (char*)malloc(len+1);
    if (hname==NULL) {
        free(hent);
        return NULL;
    }
    memcpy(hname, hent->h_name, len+1);
 
    return hname;    
}
 
 
char*  get_hostname(char* ipaddr) 
{
    char*  name;
    unsigned char* num;
 
    num  = to_address_num4(ipaddr, 1);
    if (num==NULL) return NULL;
 
    name = get_hostname_bynum(num); 
    free(num);
 
    return name;    
}
 
 
#ifdef WIN32
 
unsigned char*  get_myipaddr_num() 
{
    unsigned char* ipnum  = NULL;
    char* ipaddr = get_localip();
 
    if (ipaddr!=NULL) {
        ipnum = to_address_num8(ipaddr, 0);
        free(ipaddr);
    }
 
    return ipnum;
}
 
// #define get_myipaddr()  get_localip_bydest("202.26.158.1")
 
#else
 
unsigned char*  get_myipaddr_num() 
{
    int    i, sofd, len;
 
    unsigned char*  addr = NULL;
    struct ifconf  ifc;
    struct ifreq*  ifq;
    struct ifreq*  ifp;
 
 
    len = sizeof(struct ifreq)*MAXIFNO;
    ifp = ifq = (struct ifreq*)malloc(len);
    if (ifq==NULL) return NULL;
    memset(ifp, 0, len);
    ifc.ifc_len = len;
    ifc.ifc_req = ifq;
 
    sofd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sofd<0) {
          perror("get_myipaddr_num: socket");
        return NULL;
    }
 
 
    // インターフェイス名の取得
    if (ioctl(sofd, SIOCGIFCONF, &ifc)<0) {
        socket_close(sofd);
        free(ifq);
        return NULL;
    }
 
 
    ifp = ifq;
    for (i=0; i<MAXIFNO; i++) {
 
        // インターフェイスのフラグ取得
        if (ioctl(sofd, SIOCGIFFLAGS, ifp)<0) {
            socket_close(sofd);
            free(ifq);
            return NULL;
        }
 
        if ((ifp->ifr_flags&IFF_UP) && !(ifp->ifr_flags&IFF_LOOPBACK)) {
            int j;
            unsigned char* p = (unsigned char*)ifp->ifr_addr.sa_data;
 
            addr = (unsigned char*)malloc(8);
            if (addr==NULL) {
                socket_close(sofd);
                free(ifq);
                return NULL;
            }
            memset(addr, 0, 8);
 
            // アドレス取得
            if (ioctl(sofd, SIOCGIFADDR, ifp)<0) {
                socket_close(sofd);
                free(ifq);
                free(addr);
                return NULL;
            }
            for (j=0; j<4; j++) addr[j] = p[j+2];
 
            // ネットマスク取得
            if (ioctl(sofd, SIOCGIFNETMASK, ifp)<0) {
                socket_close(sofd);
                free(ifq);
                free(addr);
                return NULL;
            }
            for (j=0; j<4; j++) addr[j+4] = p[j+2];
 
            return addr;
        }
        ifp++;
    }
    
    socket_close(sofd);
    free(ifq);
    return NULL;
}
 
 
char*  get_myipaddr() 
{
    char* addr;
    unsigned char* n;
 
    n = get_myipaddr_num();
    if (n==NULL) return NULL;
 
    addr = (char*)malloc(32);
    if (addr==NULL) {
        free(n);
        return NULL;
    }
    memset(addr, 0, 32);
 
    snprintf(addr, 31, "%d.%d.%d.%d/%d.%d.%d.%d", n[0], n[1], n[2], n[3], n[4], n[5], n[6], n[7]);
 
    free(n);
    return addr;
}
 
#endif
 
 
char*  get_localip_bydest(char* dest)
{
    int   err, sofd;
    socklen_t len;
    char* addr;
    char* ip;
    struct sockaddr_in localif;  
    struct sockaddr_in remote;             
    
    if (dest==NULL) return NULL;     
    ip = get_ipaddr_byname(dest);
    if (ip ==NULL)  return NULL;
 
    memset(&localif, 0, sizeof(struct sockaddr_in));  
    memset(&remote,  0, sizeof(struct sockaddr_in));  
    remote.sin_family      = AF_INET;  
    remote.sin_addr.s_addr = inet_addr(ip);  
    remote.sin_port        = htons(9999);             
    free(ip);
 
    sofd = (int)socket(AF_INET, SOCK_DGRAM, 0);  
    if (sofd<0) return NULL;
 
      err = connect(sofd, (struct sockaddr*)&remote, sizeof(remote));
      if (err<0) {
          socket_close(sofd);
         return NULL;
    }
 
      len = sizeof(localif);
      err = getsockname(sofd, (struct sockaddr *)&localif, &len);
    if (err<0) {
          socket_close(sofd);
          return NULL;
    }
      socket_close(sofd);
 
    addr = get_ipaddr(localif.sin_addr);
      return addr;
}
           
 
 
char*  get_ipaddr(struct in_addr sin_addr)
{
    char* ip;
    unsigned char* pp;
 
    pp = (unsigned char*)&(sin_addr);
    if (pp[0]==0) return NULL;
 
    ip = (char*)malloc(16);
    if (ip==NULL) return NULL;
    memset(ip, 0, 16);
 
    snprintf(ip, 15, "%d.%d.%d.%d", pp[0], pp[1], pp[2], pp[3]);
 
    return ip;
}
 
 
unsigned char*  get_ipaddr_num(struct in_addr sin_addr)
{
    unsigned char* ip;
    unsigned char* pp;
 
    ip = (unsigned char*)malloc(4);
    if (ip==NULL) return NULL;
 
    pp = (unsigned char*)&(sin_addr);
    memcpy(ip, pp, 4);
 
    return ip;
}
 
 
char*  get_ipaddr_byname(char* hostname)
{
    struct hostent *host;
    char* ip;
    unsigned char* pp;
 
    host = gethostbyname(hostname); 
    if (host==NULL) return NULL;
 
    ip = (char*)malloc(16);
    if (ip==NULL) return NULL;
    memset(ip, 0, 16);
 
    pp = (unsigned char*)(host->h_addr);
    snprintf(ip, 15, "%d.%d.%d.%d", pp[0], pp[1], pp[2], pp[3]);
 
    return ip;
}
 
 
unsigned char*  get_ipaddr_byname_num(char* hostname)
{
    struct hostent *host;
    unsigned char* ip;
    unsigned char* pp;
 
    host = gethostbyname(hostname); 
    if (host==NULL) return NULL;
    ip = (unsigned char*)malloc(4);
    if (ip==NULL) return NULL;
 
    pp = (unsigned char*)(host->h_addr);
    memcpy(ip, pp, 4);
 
    return ip;
}
 
 
char*  get_mynetaddr()
{
    char* net;
    unsigned char* pp;
 
    pp = get_mynetaddr_num();
    if (pp==NULL) return NULL;
 
    net = (char*)malloc(16);
    if (net==NULL) {
        free(pp);
        return NULL;
    }
    memset(net, 0, 16);
 
    snprintf(net, 15, "%d.%d.%d.%d", pp[0], pp[1], pp[2], pp[3]);
 
    free(pp);
    return net;
}
 
 
unsigned char*  get_mynetaddr_num()
{
    int  i;
    unsigned char* net;
    unsigned char* ip;
    unsigned char* mk;
        
    ip = get_myipaddr_num();
    if (ip==NULL) return NULL;
    mk = &(ip[4]);
 
    net = (unsigned char*)malloc(4);
    if (net==NULL) {
        free(ip);
        return NULL;
    }
 
    for (i=0; i<4; i++) net[i] = ip[i] & mk[i];
 
    free(ip);
    return net;
}
 
 
struct sockaddr_in  get_sockaddr(char* hostname, unsigned short cport)
{
    struct sockaddr_in  ss_addr;
    struct hostent *shost;
 
    // Serverの情報を ss_addrに格納
    shost = gethostbyname(hostname);
    if (shost==NULL) {
        ss_addr.sin_family = 0;
        ss_addr.sin_port   = 0;
        return ss_addr;
    }
 
    memset(&ss_addr, 0, sizeof(ss_addr));
    ss_addr.sin_family = AF_INET;
    ss_addr.sin_port   = htons(cport);
    memcpy(&(ss_addr.sin_addr), shost->h_addr, shost->h_length);
 
    return ss_addr;
}
 
 
struct sockaddr_in  get_sockaddr_bynum(char* ipnum, unsigned short cport)
{
    struct sockaddr_in  ss_addr;
 
    memset(&ss_addr, 0, sizeof(ss_addr));
    ss_addr.sin_family = AF_INET;
    ss_addr.sin_port   = htons(cport);
    memcpy(&(ss_addr.sin_addr), ipnum, 4);
 
    return ss_addr;
}
 
 
struct sockaddr_in  get_local_sockaddr(unsigned short cport)
{
    struct sockaddr_in  ss_addr;
    struct hostent *shost;
 
 
    // localhost の情報を ss_addrに格納
    shost = gethostbyname("127.0.0.1");
 
    memset(&ss_addr, 0, sizeof(ss_addr));
    ss_addr.sin_family = AF_INET;
    ss_addr.sin_port   = htons(cport);
    memcpy(&(ss_addr.sin_addr), shost->h_addr, shost->h_length);
 
    return ss_addr;
}
 
 
int  is_same_sockaddr(struct sockaddr_in addr1, struct sockaddr_in addr2) 
{
    int i, len;
    unsigned char *p1, *p2;
 
    p1  = (unsigned char*)&(addr1.sin_addr);
    p2  = (unsigned char*)&(addr2.sin_addr);
    len = sizeof(addr1.sin_addr);
 
    for (i=0; i<len; i++) {
        if (p1[i]!=p2[i]) return FALSE;
    }
 
    p1  = (unsigned char*)&(addr1.sin_port);
    p2  = (unsigned char*)&(addr2.sin_port);
    len = sizeof(addr1.sin_port);
 
    for (i=0; i<len; i++) {
        if (p1[i]!=p2[i]) return FALSE;
    }
 
    return TRUE;
}
 
 
int  is_same_network_num(unsigned char* addr1, unsigned char* addr2, unsigned char* mask)
{
    int i;
 
    if (addr1==NULL || addr2==NULL) return FALSE;
 
    if (mask==NULL) {
        for (i=0; i<4; i++) {
            if (addr1[i] != addr2[i]) return FALSE;
        }
    }
    else {
        for (i=0; i<4; i++) {
            if ((addr1[i]&mask[i]) != (addr2[i]&mask[i])) return FALSE;
        }
    }
    return TRUE;
}
 
 
int  is_same_network(char* addr1, char* addr2, char* mask)
{
    int  ret;
    unsigned char* a1;
    unsigned char* a2;
    unsigned char* mk;
 
    if (addr1==NULL || addr2==NULL || mask==NULL) return FALSE;
 
    a1 = to_address_num4(addr1, 1);
    a2 = to_address_num4(addr2, 1);
    mk = to_address_num4(mask,  0);
    if (a1==NULL || a2==NULL || mk==NULL) {
        freeNull(a1);
        freeNull(a2);
        freeNull(mk);
        return FALSE;
    }
 
    ret = is_same_network_num(a1, a2, mk);
    freeNull(a1);
    freeNull(a2);
    freeNull(mk);
    
    return ret;
}
 
 
unsigned char*  to_address_num8(char* addr, int mode)
{
    unsigned char* num;
    char* ps;
    char* pc;
    char* uc = NULL;
    int   i;
 
    if (addr==NULL) return NULL;
 
    num = (unsigned char*)malloc(8);
    if (num==NULL) return NULL;
    memset(num, 0, 8);
 
 
    // IPアドレス部の変換
     ps = awk(addr, '/', 1);
    if (ps==NULL) {
        free(num);
        return NULL;
    }
 
    i = (int)strlen(ps) - 1;
    while (i>0 && ps[i]=='.') i--;
    if (i>0) {
        if (isalpha(ps[i])) {
            if (mode==0) { // mode==0なら FQDN->IPアドレス は行なわない．
                free(num);
                free(ps);
                return NULL;
            }
            uc = (char*)get_ipaddr_byname_num(ps);
            if (uc==NULL) {
                free(num);
                free(ps);
                return NULL;
            }
        }
    }
 
    if (uc==NULL) {                         // IPアドレス表記の処理    
        for (i=0; i<4; i++) {
            pc = awk(ps, '.', i+1);
            if (pc==NULL) break;
            num[i] = (unsigned char)atoi(pc);
            free(pc);
        }
    }
    else {                                     // ホスト名表記の処理
        for (i=0; i<4; i++) num[i] = uc[i];
        free(uc);
    }
    free(ps);
 
    ps = awk(addr, '/', 2);
 
    // サブネットマスク部が省略された場合の処理
    if (ps==NULL) {
        int f = OFF;
        for (i=3; i>=0; i--) {
            if (num[i]!=0 || f==ON) {
                num[i+4] = 0xff;
                f = ON;
            }
            else {
                num[i+4] = 0;
            }
        }
        return num;
    }
 
    // サブネットマスク部の処理
    for (i=0; i<4; i++) {
        pc = awk(ps, '.', i+1);
        if (pc==NULL) break;
        num[i+4] = (unsigned char)atoi(pc);
        free(pc);
    }
    free(ps);
 
    // CIDER形式対応
    if (num[4]<=32 && num[5]==0 && num[6]==0 && num[7]==0) {
        int nn, cl = (int)num[4];
        for (i=0; i<4; i++) {
            nn = 8 - Max(0, Min(8, cl-8*i));
            num[i+4] = 0xff<<nn;
        }
    }
 
    return  num;
}
 
 
char*  to_address_char8(unsigned char* n)
{
    char* addr;
    if (n==NULL) return NULL;
 
    addr = (char*)malloc(32);
    if (addr==NULL) return NULL;
    memset(addr, 0, 32);
 
    snprintf(addr, 31, "%d.%d.%d.%d/%d.%d.%d.%d", n[0], n[1], n[2], n[3], n[4], n[5], n[6], n[7]);
 
    return addr;
}
 
 
unsigned char*  to_address_num4(char* addr, int mode)
{
    unsigned char* num;
    char* pc;
    char* uc = NULL;
    int   i;
 
    if (addr==NULL) return NULL;
 
    num = (unsigned char*)malloc(4);
    if (num==NULL) return NULL;
    memset(num, 0, 4);
 
    // IPアドレス部の変換
    i = (int)strlen(addr) - 1;
    while (i>0 && addr[i]=='.') i--;
    if (i>0) {
        if (isalpha(addr[i])) {
            if (mode==0) { // mode==0なら FQDN->IPアドレス は行なわない．
                free(num);
                return NULL;
            }
            uc = (char*)get_ipaddr_byname_num(addr);
            if (uc==NULL) {
                free(num);
                return NULL;
            }
        }
    }
 
    if (uc==NULL) {                         // IPアドレス表記の処理    
        for (i=0; i<4; i++) {
            pc = awk(addr, '.', i+1);
            if (pc==NULL) break;
            num[i] = (unsigned char)atoi(pc);
            free(pc);
        }
    }
    else {                                     // ホスト名表記の処理
        for (i=0; i<4; i++) num[i] = uc[i];
        free(uc);
    }
 
    return  num;
}
 
 
char*  to_address_char4(unsigned char* n)
{
    char* addr;
    if (n==NULL) return NULL;
 
    addr = (char*)malloc(16);
    if (addr==NULL) return NULL;
    memset(addr, 0, 16);
 
    snprintf(addr, 15, "%d.%d.%d.%d", n[0], n[1], n[2], n[3]);
 
    return addr;
}
 
 
int   recv_wait(int sock, int tm)
{
    int    nd;
    fd_set mask;
    struct timeval timeout;
    time_t otm, ntm;
 
    otm = time(NULL);
    do {
        timeout.tv_sec  = tm;
        timeout.tv_usec = 0;
        FD_ZERO(&mask);
        FD_SET(sock, &mask);
 
        //DEBUG_MESG("Waiting sock = %d for %ds.\n", sock, tm);
        nd  = select(sock+1, &mask, NULL, NULL, &timeout);
        ntm = time(NULL);
    } while ((nd<0 || !FD_ISSET(sock, &mask)) && (int)(ntm-otm)<=tm);
 
    return FD_ISSET(sock, &mask);     
}
 
 
int   recv_wait_twin(int sock1, int sock2, int tm)
{
    int       ret = 0;
    int    nm, nd;
    fd_set mask;
    struct timeval timeout;
    time_t otm, ntm;
 
    nm  = Max(sock1, sock2);
    otm = time(NULL);
    do {
        timeout.tv_sec  = tm;
        timeout.tv_usec = 0;
        FD_ZERO(&mask);
        FD_SET(sock1, &mask);
        FD_SET(sock2, &mask);
        nd  = select(nm+1, &mask, NULL, NULL, &timeout);
        ntm = time(NULL);
    } while ((nd<0 || (!FD_ISSET(sock1, &mask) && !FD_ISSET(sock2, &mask))) && (int)(ntm-otm)<=tm);
 
    if (FD_ISSET(sock1, &mask)) ret += 1;
    if (FD_ISSET(sock2, &mask)) ret += 2;
 
    return ret;
}
 
 
int   send_wait(int sock, int tm)
{
    int    nd;
    fd_set mask;
    struct timeval timeout;
    time_t otm, ntm;
 
    otm = time(NULL);
    do {
        timeout.tv_sec  = tm;
        timeout.tv_usec = 0;
        FD_ZERO(&mask);
        FD_SET(sock, &mask);
 
        //DEBUG_MESG("Waiting sock = %d for %ds.\n", sock, tm);
        nd  = select(sock+1, NULL, &mask, NULL, &timeout);
        ntm = time(NULL);
    } while ((nd<0 || !FD_ISSET(sock, &mask)) && (int)(ntm-otm)<=tm);
 
    return FD_ISSET(sock, &mask);     
}
 
 
void  udp_hole_punching(int sock, struct sockaddr_in addr, int nm)
{
    char data[LBUF];
 
    if (nm<=0) nm = 4;                // for SLVoice
    else if (nm>LBUF) nm = LBUF;
 
    memset(data, 0, nm);
    udp_send(sock, data, nm, &addr);
 
    return;
}
 
 
 
// get_valid_..._socket
//
 
int  get_valid_udp_socket(int min, int max, unsigned short* port)
{
    int  i, sock, range;
 
    range = max - min + 1;
    *port = rand()%range + min;
 
    i = 1;
    sock = udp_server_socket((int)*port);
    while(sock<=0 && i<range) {
        (*port)++;
        if (*port>max) *port = ((int)*port)%max + min - 1;
        sock = udp_server_socket((int)*port);
        i++;
    }
 
    if (sock<=0) *port = 0;
 
    return sock;
}
 
 
int  get_valid_tcp_server_socket(int min, int max, unsigned short* port)
{
    int  i, sock, range;
 
    range = max - min + 1;
    *port = rand()%range + min;
 
    i = 1;
    sock = tcp_server_socket((int)*port);
    while(sock<=0 && i<range) {
        (*port)++;
        if (*port>max) *port = ((int)*port)%max + min - 1;
        sock = tcp_server_socket((int)*port);
        i++;
    }
 
    if (sock<=0) *port = 0;
 
    return sock;
}
 
 
int  get_valid_tcp_client_socket(int min, int max, char* hname, unsigned short sport, unsigned short* cport)
{
    int  i, sock, range;
 
    range  = max - min + 1;
    *cport = rand()%range + min;
 
    i = 1;
    sock = tcp_client_bind_socket(hname, (int)sport, (int)*cport);
    while(sock<0 && i<range) {
        (*cport)++;
        if (*cport>max) *cport = ((int)*cport)%max + min - 1;
        sock = tcp_client_bind_socket(hname, (int)sport, (int)*cport);
        i++;
    }
 
    if (sock<=0) *cport = 0;
 
    return sock;
}
 
 
 
//
// for WinSock
//
 
#ifdef WIN32
    WSADATA WsaData;
#endif
 
 
int  init_network(void)
{
    int ret = 0;
 
#ifdef WIN32
    ret = WSAStartup(MAKEWORD(2,0), &WsaData);
    if (ret!=0) WSACleanup();
#endif
 
    return  ret;
}
 
 
void  cleanup_network(void)
{
#ifdef WIN32
    WSACleanup();
#endif
}