Lib/network6.c File Reference

ネットワーク用ライブラリ for IPv4/IPv6 More...

#include "network.h"
#include <time.h>
#include <ifaddrs.h>
Include dependency graph for network6.c:

Go to the source code of this file.

Functions

int init_network (void)
void cleanup_network (void)
int _udp_server_socket (int port, struct addrinfo **sv_addr, int family)
 call socket(), bind()
int _udp_server_socket_setopt (int port, int opt, const void *optval, int optlen, struct addrinfo **sv_addr, int family)
 call socket(), setsockopt(), bind()
int _udp_client_socket (char *hostname, int port, struct addrinfo **sv_addr, int family)
 call socket()
int _udp_bind (int sofd, int port, int family)
 call bind()
int _udp_bind_setopt (int sofd, int port, int opt, const void *optval, int optlen, int family)
 call setsockopt(), bind()
int _tcp_server_socket (int port, int family)
 call socket(), bind(), listen()
int _tcp_server_socket_setopt (int port, int opt, const void *optval, int optlen, int family)
 call socket(), setsockopt(), bind(), listen()
int _tcp_server_bind (int port, int family)
 call socket(), bind()
int _tcp_server_bind_setopt (int port, int opt, const void *optval, int optlen, int family)
 call socket(), setsockopt(), bind()
int _tcp_client_socket (char *hostname, int port, int family)
 call socket(), connect()
int _tcp_client_bind_socket (char *hostname, int sport, int cport, int family)
 call socket(), bind(), connect()
int _tcp_bind (int sofd, int port, int family)
 call bind()
int _tcp_bind_setopt (int sofd, int port, int opt, const void *optval, int optlen, int family)
 call setsockopt(), bind()
int _tcp_connect (int sofd, char *hostname, int port, int family)
 call connect()
int accept_intr (int sock, struct sockaddr *cl_addr, socklen_t *cdlen)
 call accept()
int socket_close (int sofd)
 call shutdown(), close()
int set_nonblock_socket (int sock)
int set_block_socket (int sock)
int get_valid_udp_socket (int min, int max, unsigned short *port)
int get_valid_tcp_server_socket (int min, int max, unsigned short *port)
int get_valid_tcp_client_socket (int min, int max, char *hname, unsigned short sport, unsigned short *cport)
int udp_recv (int sock, char *rmsg, int size, struct addrinfo *sv_addr)
int udp_send (int sock, char *smsg, int size, struct addrinfo *sv_addr)
int tcp_recv (int sock, char *rmsg, int size)
int tcp_send (int sock, char *smsg, int size)
int udp_recv_wait (int sock, char *rmsg, int size, struct addrinfo *sv_addr, int tm)
int tcp_recv_wait (int sock, char *mesg, int sz, int tm)
int tcp_send_mesgln (int sock, char *mesg)
int tcp_recv_mstream (int sock, char *mesg, int sz, mstream *sb, int tm)
int recv_wait (int sock, int tm)
int recv_wait_twin (int sock1, int sock2, int tm)
int send_wait (int sock, int tm)
struct sockaddr * make_sockaddr_bynum (unsigned char *addr, int port, int family)
 IPv4/IPv6 対応.
struct sockaddr * make_sockaddr_bystr (const char *addr, int port)
 IPv4/IPv6 対応.
char * get_hostname_bynum (unsigned char *num, int family)
 IPv4/IPv6 アドレス（バイナリ）→ ホスト名（文字列）.
char * get_hostname_bystr (const char *addr)
 IPv4/IPv6 アドレス（文字列） → ホスト名（文字列）.
char * _get_hostname (const char *addr, int family)
 IPv4/IPv6 アドレス（文字列）, FQDN → ホスト名（文字列）.
char * get_ipaddr_byname (const char *hostname, int family)
 ホスト名 → IPv4/IPv6 アドレス（文字列）
unsigned char * get_ipaddr_byname_num (const char *hostname, int family)
 ホスト名 → IPv4/IPv6 アドレス（バイナリ）
char * get_myipaddr (int family)
 自分の [IPv4/IPv6 ネットワークアドレス]/[ネットマスク]（文字列）
unsigned char * get_myipaddr_num (int family)
 自分の [IPv4/IPv6 アドレス],[ネットマスク]（バイナリ）
char * _get_localip_bydest (const char *dest, int family)
 自分の IPv4/IPv6 アドレス（文字列）
char * get_mynetaddr (int family)
 自分の IPv4/IPv6 ネットワークアドレス（文字列）
unsigned char * get_mynetaddr_num (int family)
 自分の IPv4/IPv6 ネットワークアドレス（バイナリ）
int is_same_sockaddr (struct sockaddr *addr1, struct sockaddr *addr2)
int is_same_network (char *addr1, char *addr2, char *mask)
int is_same_network_num (unsigned char *addr1, unsigned char *addr2, unsigned char *mask, int family)
unsigned char * to_address_num (char *addr, int mode, int mask, int family)
 IPv4/IPv6 アドレス（文字列）→ [IPv4/IPv6 アドレス],[ネットマスク]（数字8/32Byte）.
char * to_address_char (unsigned char *addr, int mask, int family)
 [IPv4/IPv6 アドレス],[ネットマスク]（数字8/32Byte）→ IPv4/IPv6 アドレス（文字列）
void udp_hole_punching (int sock, struct addrinfo *addr, int nm)
int udp_client_socket_sockaddr_in (char *hostname, int port, struct sockaddr_in *sv_addr)
 use udp_client_socket()
int udp_recv_sockaddr_in (int sock, char *rmsg, int size, struct sockaddr_in *sv_addr)
 use udp_recv()
int udp_send_sockaddr_in (int sock, char *smsg, int size, struct sockaddr_in *sv_addr)
 use udp_send()
int udp_recv_wait_sockaddr_in (int sock, char *rmsg, int size, struct sockaddr_in *sv_addr, int tm)
 use udp_recv_wait()
struct sockaddr_in get_sockaddr_in (char *hostname, unsigned short cport)
struct sockaddr_in get_sockaddr_in_bynum (char *ipnum, unsigned short cport)
struct sockaddr_in get_local_sockaddr_in (unsigned short cport)
char * get_ipaddr_ipv4 (struct in_addr sin_addr)
 構造体 → IPv4 アドレス（文字列） use get_ipaddr_byname()
unsigned char * get_ipaddr_num_ipv4 (struct in_addr sin_addr)
 構造体 → IPv4 アドレス（バイナリ） use get_ipaddr_byname_num()
void udp_hole_punching_sockaddr_in (int sock, struct sockaddr_in addr, int nm)
 use udp_hole_punching()

Detailed Description

Author:
Fumi.Iseki (C)

Definition in file network6.c.

Function Documentation

char* _get_hostname ( const char *  addr,
int  family 
)

char* _get_hostname(const char* addr, int family)

IPv4/IPv6 アドレス（文字列）からホスト名を逆引きする．

FQDNを指定した場合は，正引きして逆引きするので，FQDNのチェックに使用できる．

Parameters:
addr IPアドレス（文字列）または FQDN
family プロトコルファミリー（AF_INET/AF_INET6)
Returns:
ホスト名（文字列）．要 free

Definition at line 1761 of file network6.c.

References LNAME.

01762 {
01763     int   len, err;
01764     char  htemp[LNAME];
01765     char* hname = NULL;
01766 
01767     struct addrinfo  hints;
01768     struct addrinfo* address;
01769     struct sockaddr* sa;
01770  
01771     if (addr==NULL) return NULL;
01772     if (family!=AF_INET && family!=AF_INET6 && family!=AF_UNSPEC) family = AF_UNSPEC;
01773 
01774     memset(&hints, 0, sizeof(struct addrinfo));
01775     hints.ai_family   = family;
01776     hints.ai_flags    = AI_PASSIVE;
01777     hints.ai_socktype = SOCK_DGRAM;  
01778 
01779     err = getaddrinfo(addr, 0, &hints, &address);
01780     if (err!=0 || address==NULL) return NULL;
01781     sa = (struct sockaddr*)address->ai_addr;
01782 
01783     if (sa->sa_family==AF_INET6) len = sizeof(struct sockaddr_in6);
01784     else                         len = sizeof(struct sockaddr_in);
01785     err = getnameinfo(sa, len, htemp, LNAME-1, NULL, 0, 0);
01786     if (err!=0) {
01787         freeaddrinfo(address);
01788         return NULL;
01789     }
01790 
01791     len = (int)strlen(htemp);
01792     hname = (char*)malloc(len+1);
01793     if (hname==NULL) {
01794         freeaddrinfo(address);
01795         return NULL;
01796     }
01797 
01798     freeaddrinfo(address);
01799     memcpy(hname, htemp, len+1);
01800     return hname;    
01801 }

char* _get_localip_bydest ( const char *  dest,
int  family 
)

char* _get_localip_bydest(const char* dest, int family)

接続先を指定して，そこへ接続する インターフェイスのIPアドレスを得る．自分自身の IPアドレスを得るもう一つの方法．

Parameters:
dest 接続先の IPv4/IPv6 アドレス または FQDN
family プロトコルファミリー（AF_INET/AF_INET6)
Returns:
IPv4/IPv6 アドレス(文字列)へのポインタ．要 free

Definition at line 2099 of file network6.c.

References LEN_IPADDR, LEN_IPADDR6, and socket_close().

02100 {
02101     int   sofd, err, len;
02102     char* addr;
02103     unsigned char* pp;
02104     struct addrinfo  hints;
02105     struct addrinfo* sv_addr;
02106     struct sockaddr* sa;             
02107 
02108     if (family!=AF_INET && family!=AF_INET6 && family!=AF_UNSPEC) family = AF_UNSPEC;
02109 
02110     memset(&hints, 0, sizeof(struct addrinfo));
02111     hints.ai_family   = family;       
02112     hints.ai_flags    = AI_PASSIVE;
02113     hints.ai_socktype = SOCK_DGRAM;
02114 
02115     err = getaddrinfo(dest, "9999", &hints, &sv_addr);
02116     if (err != 0) {
02117         // if 10093 error is occured, execute init_network()
02118         return NULL;
02119     }
02120 
02121     sofd = (int)socket(sv_addr->ai_family, sv_addr->ai_socktype, sv_addr->ai_protocol);
02122     if (sofd<0) {
02123         freeaddrinfo(sv_addr);
02124         return NULL;
02125     }
02126 
02127     err = connect(sofd, sv_addr->ai_addr, (int)sv_addr->ai_addrlen);
02128     if (err<0) {
02129         socket_close(sofd);
02130         return NULL;
02131     }
02132 
02133     if (sv_addr->ai_family==AF_INET6) {
02134         len = sizeof(struct sockaddr_in6);
02135         sa  = (struct sockaddr*)malloc(len);
02136         memset(sa, 0, len);
02137         err = getsockname(sofd, (struct sockaddr *)sa, (socklen_t*)&len);
02138         //pp = (unsigned char*)(((struct sockaddr_in6*)sa)->sin6_addr.s6_addr);
02139         pp = (unsigned char*)&(((struct sockaddr_in6*)sa)->sin6_addr);
02140         len = LEN_IPADDR6;
02141     }
02142     else {
02143         len = sizeof(struct sockaddr_in);
02144         sa  = (struct sockaddr*)malloc(len);
02145         memset(sa, 0, len);
02146         err = getsockname(sofd, (struct sockaddr *)sa, (socklen_t*)&len);
02147         //pp = (unsigned char*)(&((struct sockaddr_in*)sa)->sin_addr.s_addr);
02148         pp = (unsigned char*)&(((struct sockaddr_in*)sa)->sin_addr);
02149         len = LEN_IPADDR;
02150     }
02151 
02152     freeaddrinfo(sv_addr);
02153     socket_close(sofd);
02154 
02155     addr = (char*)malloc(len);
02156     if (addr==NULL) {
02157         free(sa);
02158         return NULL;
02159     }
02160 
02161     inet_ntop(family, pp, addr, len);
02162     free(sa);
02163     return addr;
02164 }

Here is the call graph for this function:

int _tcp_bind ( int  sofd,
int  port,
int  family 
)

int _tcp_bind(int sofd, int port, int family)

IPv4/IPv6 のTCPソケットにポートをバインドする．

Parameters:
sofd バインドするソケットの記述子．
port ポート番号
family プロトコルファミリー（AF_INET/AF_INET6/AF_UNSPEC)． AF_UNSPEC の場合は先ずIPv6で接続を試み，不可ならIPv4で接続する．
Return values:
0以上 作成されたソケット記述子．
JBXL_NET_BIND_ERROR バインドに失敗．
JBXL_NET_INFO_ERROR ホスト情報の取得に失敗．

Definition at line 847 of file network6.c.

References freeNull, itostr_ts(), JBXL_NET_BIND_ERROR, JBXL_NET_INFO_ERROR, and socket_close().

00848 {
00849     int    err;
00850     struct addrinfo  hints;
00851     struct addrinfo* address;
00852  
00853     if (sofd<=0) return sofd;
00854     if (family!=AF_INET && family!=AF_INET6 && family!=AF_UNSPEC) family = AF_UNSPEC;
00855 
00856     memset(&hints, 0, sizeof(struct addrinfo));
00857     hints.ai_family   = family;
00858     hints.ai_flags    = AI_PASSIVE;
00859     hints.ai_socktype = SOCK_STREAM;  
00860 
00861     char* str = itostr_ts(port);
00862     err = getaddrinfo(NULL, str, &hints, &address);
00863     freeNull(str);
00864     if (err!=0) {
00865         socket_close(sofd);
00866         return JBXL_NET_INFO_ERROR;
00867     }
00868 
00869     err = bind(sofd, address->ai_addr, (int)address->ai_addrlen);
00870     if (err<0) {
00871         freeaddrinfo(address);
00872         socket_close(sofd);
00873         return JBXL_NET_BIND_ERROR;
00874     }
00875 
00876     freeaddrinfo(address);
00877     return sofd;
00878 }

Here is the call graph for this function:

int _tcp_bind_setopt ( int  sofd,
int  port,
int  opt,
const void *  optval,
int  optlen,
int  family 
)

int _tcp_bind_setopt(int sofd, int port, int opt, const void* optval, int optlen, int family)

IPv4/IPv6 のTCPソケットにポートをバインドする．オプションの指定（setsockopt）が可能．

Parameters:
sofd バインドするソケットの記述子．
port ポート番号
opt オプションの種類
optval オプションデータ
optlen optval の長さ
family プロトコルファミリー（AF_INET/AF_INET6/AF_UNSPEC)． AF_UNSPEC の場合は先ずIPv6で接続を試み，不可ならIPv4で接続する．
Return values:
0以上 作成されたソケット記述子．
JBXL_NET_OPTION_ERROR オプションの設定に失敗．
JBXL_NET_BIND_ERROR バインドに失敗．
JBXL_NET_INFO_ERROR ホスト情報の取得に失敗．

Definition at line 900 of file network6.c.

References freeNull, itostr_ts(), JBXL_NET_BIND_ERROR, JBXL_NET_INFO_ERROR, JBXL_NET_OPTION_ERROR, and socket_close().

00901 {
00902     int    err;
00903     struct addrinfo  hints;
00904     struct addrinfo* address;
00905  
00906     if (sofd<=0) return sofd;
00907     if (family!=AF_INET && family!=AF_INET6 && family!=AF_UNSPEC) family = AF_UNSPEC;
00908 
00909     if (opt>0) {
00910         #ifdef WIN32
00911             err = setsockopt(sofd, SOL_SOCKET, opt, (const char*)optval, optlen);
00912         #else
00913             err = setsockopt(sofd, SOL_SOCKET, opt, optval, optlen);
00914         #endif
00915         if (err<0) {
00916             socket_close(sofd);
00917             return JBXL_NET_OPTION_ERROR;
00918         } 
00919     }
00920 
00921     memset(&hints, 0, sizeof(struct addrinfo));
00922     hints.ai_family   = family;
00923     hints.ai_flags    = AI_PASSIVE;
00924     hints.ai_socktype = SOCK_STREAM;  
00925 
00926     char* str = itostr_ts(port);
00927     err = getaddrinfo(NULL, str, &hints, &address);
00928     freeNull(str);
00929     if (err!=0) {
00930         socket_close(sofd);
00931         return JBXL_NET_INFO_ERROR;
00932     }
00933 
00934     err = bind(sofd, address->ai_addr, (int)address->ai_addrlen);
00935     if (err<0) {
00936         freeaddrinfo(address);
00937         socket_close(sofd);
00938         return JBXL_NET_BIND_ERROR;
00939     }
00940 
00941     freeaddrinfo(address);
00942     return sofd;
00943 }

Here is the call graph for this function:

int _tcp_client_bind_socket ( char *  hostname,
int  sport,
int  cport,
int  family 
)

int _tcp_client_bind_socket(char* hostname, int sport, int cport, int family)

IPv4/IPv6 のTCPのクライアントソケットを作り，サーバに接続する．

この関数内で呼び出されるネットワーク関数: socket(), bind(), getaddrinfo(), connect()

Parameters:
hostname サーバ名
sport サーバポート番号
cport 自分のポート番号
family プロトコルファミリー（AF_INET/AF_INET6/AF_UNSPEC)． AF_UNSPEC の場合は先ずIPv6で接続を試み，不可ならIPv4で接続する．
Return values:
0以上 作成されたソケット記述子．
JBXL_NET_SOCKET_ERROR ソケットが作成できなかった．
JBXL_NET_BIND_ERROR バインドに失敗．
JBXL_NET_INFO_ERROR ホスト情報の取得に失敗．
JBXL_NET_CONNECT_ERROR 接続に失敗．

Definition at line 779 of file network6.c.

References freeNull, itostr_ts(), JBXL_NET_BIND_ERROR, JBXL_NET_CONNECT_ERROR, JBXL_NET_INFO_ERROR, JBXL_NET_SOCKET_ERROR, and socket_close().

00780 {
00781     int    sofd, err;
00782     struct addrinfo  hints;
00783     struct addrinfo* address;
00784  
00785     if (family!=AF_INET && family!=AF_INET6 && family!=AF_UNSPEC) family = AF_UNSPEC;
00786 
00787     memset(&hints, 0, sizeof(struct addrinfo));
00788     hints.ai_family   = family;
00789     hints.ai_flags    = AI_PASSIVE;
00790     hints.ai_socktype = SOCK_STREAM;  
00791 
00792     char* str = itostr_ts(cport);
00793     err = getaddrinfo(NULL, str, &hints, &address);
00794     freeNull(str);
00795     if (err!=0) return JBXL_NET_INFO_ERROR;
00796 
00797     sofd = (int)socket(address->ai_family, address->ai_socktype, address->ai_protocol);
00798     if (sofd<0) {
00799         freeaddrinfo(address);
00800         return JBXL_NET_SOCKET_ERROR;
00801     }
00802 
00803     err = bind(sofd, address->ai_addr, (int)address->ai_addrlen);
00804     if (err<0) {
00805         freeaddrinfo(address);
00806         socket_close(sofd);
00807         return JBXL_NET_BIND_ERROR;
00808     }
00809     freeaddrinfo(address);
00810 
00811     //
00812     str = itostr_ts(sport);
00813     err = getaddrinfo(hostname, str, &hints, &address);
00814     freeNull(str);
00815     if (err!=0) {
00816         socket_close(sofd);
00817         return JBXL_NET_INFO_ERROR;
00818     }
00819 
00820     err = connect(sofd, address->ai_addr, (int)address->ai_addrlen);
00821     if (err<0) {
00822         freeaddrinfo(address);
00823         socket_close(sofd);
00824         return JBXL_NET_CONNECT_ERROR;
00825     }
00826 
00827     freeaddrinfo(address);
00828     return sofd;
00829 }

Here is the call graph for this function:

int _tcp_client_socket ( char *  hostname,
int  port,
int  family 
)

int _tcp_client_socket(char* hostname, int port, int family)

IPv4/IPv6 のTCPのクライアントソケットを作り，サーバに接続する．

この関数内で呼び出されるネットワーク関数: socket(), getaddrinfo(), connect()

Parameters:
hostname サーバ名
port サーバポート番号
family プロトコルファミリー（AF_INET/AF_INET6/AF_UNSPEC)． AF_UNSPEC の場合は先ずIPv6で接続を試み，不可ならIPv4で接続する．
Return values:
0以上 作成されたソケット記述子．
JBXL_NET_SOCKET_ERROR ソケットが作成できなかった．
JBXL_NET_INFO_ERROR ホスト情報の取得に失敗．
JBXL_NET_CONNECT_ERROR 接続に失敗．

Definition at line 723 of file network6.c.

References freeNull, itostr_ts(), JBXL_NET_CONNECT_ERROR, JBXL_NET_INFO_ERROR, JBXL_NET_SOCKET_ERROR, and socket_close().

00724 {
00725     int    sofd, err;
00726     struct addrinfo  hints;
00727     struct addrinfo* address;
00728  
00729     if (family!=AF_INET && family!=AF_INET6 && family!=AF_UNSPEC) family = AF_UNSPEC;
00730 
00731     memset(&hints, 0, sizeof(struct addrinfo));
00732     hints.ai_family   = family;
00733     hints.ai_flags    = AI_PASSIVE;
00734     hints.ai_socktype = SOCK_STREAM;  
00735 
00736     char* str = itostr_ts(port);
00737     err = getaddrinfo(hostname, str, &hints, &address);
00738     freeNull(str);
00739     if (err!=0) return JBXL_NET_INFO_ERROR;
00740 
00741     sofd = (int)socket(address->ai_family, address->ai_socktype, address->ai_protocol);
00742     if (sofd<0) {
00743         freeaddrinfo(address);
00744         return JBXL_NET_SOCKET_ERROR;
00745     }
00746 
00747     err = connect(sofd, address->ai_addr, (int)address->ai_addrlen);
00748     if (err<0) {
00749         freeaddrinfo(address);
00750         socket_close(sofd);
00751         return JBXL_NET_CONNECT_ERROR;
00752     }
00753 
00754     freeaddrinfo(address);
00755     return sofd;
00756 }

Here is the call graph for this function:

int _tcp_connect ( int  sofd,
char *  hostname,
int  port,
int  family 
)

Definition at line 964 of file network6.c.

References freeNull, itostr_ts(), JBXL_NET_CONNECT_ERROR, JBXL_NET_INFO_ERROR, and socket_close().

00965 {
00966     int    err;
00967     struct addrinfo  hints;
00968     struct addrinfo* address;
00969  
00970     if (family!=AF_INET && family!=AF_INET6 && family!=AF_UNSPEC) family = AF_UNSPEC;
00971 
00972     memset(&hints, 0, sizeof(struct addrinfo));
00973     hints.ai_family   = family;
00974     hints.ai_flags    = AI_PASSIVE;
00975     hints.ai_socktype = SOCK_STREAM;  
00976 
00977     char* str = itostr_ts(port);
00978     err = getaddrinfo(hostname, str, &hints, &address);
00979     freeNull(str);
00980     if (err!=0) {
00981         socket_close(sofd);
00982         return JBXL_NET_INFO_ERROR;
00983     }
00984 
00985     err = connect(sofd, address->ai_addr, (int)address->ai_addrlen);
00986     if (err<0) {
00987         freeaddrinfo(address);
00988         socket_close(sofd);
00989         return JBXL_NET_CONNECT_ERROR;
00990     }
00991 
00992     freeaddrinfo(address);
00993     return 0;
00994 }

Here is the call graph for this function:

int _tcp_server_bind ( int  port,
int  family 
)

int _tcp_server_bind(int port, int family)

IPv4/IPv6 のTCPのサーバのソケット記述子を作り，バインドする． tcp_server_socket() との違いは listen()関数を呼び出さない点にある．

この関数内で呼び出されるネットワーク関数: socket(), bind()

Parameters:
port ポート番号．
family プロトコルファミリー（AF_INET/AF_INET6/AF_UNSPEC)． AF_UNSPEC の場合は先ずIPv6で接続を試み，不可ならIPv4で接続する．
Return values:
0以上 作成されたソケット記述子．
JBXL_NET_SOCKET_ERROR ソケットが作成できなかった．
JBXL_NET_BIND_ERROR バインドに失敗．
JBXL_NET_INFO_ERROR ホスト情報の取得に失敗．

Definition at line 571 of file network6.c.

References FALSE, freeNull, itostr_ts(), JBXL_NET_BIND_ERROR, JBXL_NET_INFO_ERROR, JBXL_NET_OPTION_ERROR, JBXL_NET_SOCKET_ERROR, set_nonblock_socket(), socket_close(), and TRUE.

00572 {
00573     int    sofd, err;
00574     struct addrinfo  hints;
00575     struct addrinfo* address;
00576     int    nonblock = FALSE;
00577 
00578     if (family!=AF_INET && family!=AF_INET6 && family!=AF_UNSPEC) family = AF_UNSPEC;
00579 
00580     memset(&hints, 0, sizeof(struct addrinfo));
00581     hints.ai_family   = family;
00582     hints.ai_flags    = AI_PASSIVE;
00583     hints.ai_socktype = SOCK_STREAM;  
00584 
00585     if (port<0) {
00586         nonblock = TRUE;
00587         port = -port;
00588     }
00589 
00590     char* str = itostr_ts(port);
00591     err = getaddrinfo(NULL, str, &hints, &address);
00592     freeNull(str);
00593     if (err!=0) return JBXL_NET_INFO_ERROR;
00594 
00595     sofd = (int)socket(address->ai_family, address->ai_socktype, address->ai_protocol);
00596     if (sofd<0) {
00597         freeaddrinfo(address);
00598         return JBXL_NET_SOCKET_ERROR;
00599     }
00600     if (nonblock) sofd = set_nonblock_socket(sofd);
00601 
00602     // TIME_WAIT しない設定．
00603     int lg = 1;
00604     #ifdef WIN32
00605         err = setsockopt(sofd, SOL_SOCKET, SO_REUSEADDR, (const char*)&lg, sizeof(lg));
00606     #else
00607         err = setsockopt(sofd, SOL_SOCKET, SO_REUSEADDR, &lg, sizeof(lg));
00608     #endif
00609     if (err<0) {
00610         freeaddrinfo(address);
00611         socket_close(sofd);
00612         return JBXL_NET_OPTION_ERROR;
00613     }
00614 
00615     err = bind(sofd, address->ai_addr, (int)address->ai_addrlen);
00616     if (err<0) {
00617         freeaddrinfo(address);
00618         socket_close(sofd);
00619         return JBXL_NET_BIND_ERROR;
00620     }
00621 
00622     freeaddrinfo(address);
00623     return sofd;
00624 }

Here is the call graph for this function:

int _tcp_server_bind_setopt ( int  port,
int  opt,
const void *  optval,
int  optlen,
int  family 
)

int _tcp_server_bind_setopt(int port, int opt, const void* optval, int optlen, int family)

IPv4/IPv6 のTCPのサーバのソケット記述子を作り，バインドする．オプションの指定（setsockopt）が可能． tcp_server_socket() との違いは listen()関数を呼び出さない点にある．

この関数内で呼び出されるネットワーク関数: socket(), setsockopt(), bind()

Parameters:
port ポート番号
opt オプションの種類
optval オプションデータ
optlen optval の長さ
family プロトコルファミリー（AF_INET/AF_INET6/AF_UNSPEC)． AF_UNSPEC の場合は先ずIPv6で接続を試み，不可ならIPv4で接続する．
Return values:
0以上 作成されたソケット記述子．
JBXL_NET_SOCKET_ERROR ソケットが作成できなかった．
JBXL_NET_OPTION_ERROR オプションの設定に失敗．
JBXL_NET_BIND_ERROR バインドに失敗．
JBXL_NET_INFO_ERROR ホスト情報の取得に失敗．

Definition at line 649 of file network6.c.

References FALSE, freeNull, itostr_ts(), JBXL_NET_BIND_ERROR, JBXL_NET_INFO_ERROR, JBXL_NET_OPTION_ERROR, JBXL_NET_SOCKET_ERROR, set_nonblock_socket(), socket_close(), and TRUE.

00650 {
00651     int    sofd, err;
00652     struct addrinfo  hints;
00653     struct addrinfo* address;
00654     int    nonblock = FALSE;
00655  
00656     if (family!=AF_INET && family!=AF_INET6 && family!=AF_UNSPEC) family = AF_UNSPEC;
00657 
00658     memset(&hints, 0, sizeof(struct addrinfo));
00659     hints.ai_family   = family;
00660     hints.ai_flags    = AI_PASSIVE;
00661     hints.ai_socktype = SOCK_STREAM;  
00662 
00663     if (port<0) {
00664         nonblock = TRUE;
00665         port = -port;
00666     }
00667 
00668     char* str = itostr_ts(port);
00669     err = getaddrinfo(NULL, str, &hints, &address);
00670     freeNull(str);
00671     if (err!=0) return JBXL_NET_INFO_ERROR;
00672 
00673     sofd = (int)socket(address->ai_family, address->ai_socktype, address->ai_protocol);
00674     if (sofd<0) {
00675         freeaddrinfo(address);
00676         return JBXL_NET_SOCKET_ERROR;
00677     }
00678     if (nonblock) sofd = set_nonblock_socket(sofd);
00679 
00680     if (opt>0) {
00681         #ifdef WIN32
00682             err = setsockopt(sofd, SOL_SOCKET, opt, (const char*)optval, optlen);
00683         #else
00684             err = setsockopt(sofd, SOL_SOCKET, opt, optval, optlen);
00685         #endif
00686         if (err<0) {
00687             freeaddrinfo(address);
00688             socket_close(sofd);
00689             return JBXL_NET_OPTION_ERROR;
00690         }
00691     }
00692 
00693     err = bind(sofd, address->ai_addr, (int)address->ai_addrlen);
00694     if (err<0) {
00695         freeaddrinfo(address);
00696         socket_close(sofd);
00697         return JBXL_NET_BIND_ERROR;
00698     }
00699 
00700     freeaddrinfo(address);
00701     return sofd;
00702 }

Here is the call graph for this function:

int _tcp_server_socket ( int  port,
int  family 
)

int _tcp_server_socket(int port, int family)

IPv4/IPv6 のTCPのサーバソケットを作り，リッスンにより接続要求を受けられる状態にする．
この関数に続いて accept()関数を呼ぶ事により,実際の接続待ち状態となる．

この関数内で呼び出されるネットワーク関数は socket(), bind(), listen()

Parameters:
port ポート番号．マイナスの場合は ノンブロックとなる．
family プロトコルファミリー（AF_INET/AF_INET6/AF_UNSPEC)． AF_UNSPEC の場合は先ずIPv6で接続を試み，不可ならIPv4で接続する．
Return values:
0以上 作成されたソケット記述子．
JBXL_NET_SOCKET_ERROR ソケットが作成できなかった．
JBXL_NET_BIND_ERROR バインドに失敗．
JBXL_NET_INFO_ERROR ホスト情報の取得に失敗．
JBXL_NET_LISTEN_ERROR リッスンに失敗．

Definition at line 403 of file network6.c.

References FALSE, freeNull, itostr_ts(), JBXL_NET_BIND_ERROR, JBXL_NET_INFO_ERROR, JBXL_NET_LISTEN_ERROR, JBXL_NET_OPTION_ERROR, JBXL_NET_SOCKET_ERROR, set_nonblock_socket(), socket_close(), and TRUE.

00404 {
00405     int    sofd, err;
00406     struct addrinfo  hints;
00407     struct addrinfo* address;
00408     int    nonblock = FALSE;
00409  
00410     if (family!=AF_INET && family!=AF_INET6 && family!=AF_UNSPEC) family = AF_UNSPEC;
00411 
00412     memset(&hints, 0, sizeof(struct addrinfo));
00413     hints.ai_family   = family;
00414     hints.ai_flags    = AI_PASSIVE;
00415     hints.ai_socktype = SOCK_STREAM;  
00416 
00417     if (port<0) {
00418         nonblock = TRUE;
00419         port = -port;
00420     }
00421 
00422     char* str = itostr_ts(port);
00423     err = getaddrinfo(NULL, str, &hints, &address);
00424     freeNull(str);
00425     if (err!=0) return JBXL_NET_INFO_ERROR;
00426 
00427     sofd = (int)socket(address->ai_family, address->ai_socktype, address->ai_protocol);
00428     if (sofd<0) {
00429         freeaddrinfo(address);
00430         return JBXL_NET_SOCKET_ERROR;
00431     }
00432     if (nonblock) sofd = set_nonblock_socket(sofd);
00433 
00434     // TIME_WAIT しない設定．
00435     int lg = 1;
00436     #ifdef WIN32
00437         err = setsockopt(sofd, SOL_SOCKET, SO_REUSEADDR, (const char*)&lg, sizeof(lg));
00438     #else
00439         err = setsockopt(sofd, SOL_SOCKET, SO_REUSEADDR, &lg, sizeof(lg));
00440     #endif
00441     if (err<0) {
00442         freeaddrinfo(address);
00443         socket_close(sofd);
00444         return JBXL_NET_OPTION_ERROR;
00445     }
00446 
00447     err = bind(sofd, address->ai_addr, (int)address->ai_addrlen);
00448     if (err<0) {
00449         freeaddrinfo(address);
00450         socket_close(sofd);
00451         return JBXL_NET_BIND_ERROR;
00452     }
00453 
00454     err = listen(sofd, 10);
00455     if (err==-1) {
00456         freeaddrinfo(address);
00457         socket_close(sofd);
00458         return JBXL_NET_LISTEN_ERROR;
00459     }
00460 
00461     freeaddrinfo(address);
00462     return sofd;
00463 }

Here is the call graph for this function:

int _tcp_server_socket_setopt ( int  port,
int  opt,
const void *  optval,
int  optlen,
int  family 
)

int _tcp_server_socket_setopt(int port, int opt, const void* optval, int optlen, int family)

IPv4/IPv6 のTCPのサーバソケットを作り，リッスンにより接続要求を受けられる状態にする．
この関数に続いて accept()関数を呼ぶ事により,実際の接続待ち状態となる． オプションの指定（setsockopt）が可能．

この関数内で呼び出されるネットワーク関数は socket(), setsockopt(), bind(), listen()

Parameters:
port ポート番号．マイナスの場合は ノンブロックとなる．
opt オプションの種類
optval オプションデータ
optlen optval の長さ
family プロトコルファミリー（AF_INET/AF_INET6/AF_UNSPEC)． AF_UNSPEC の場合は先ずIPv6で接続を試み，不可ならIPv4で接続する．
Return values:
0以上 作成されたソケット記述子．
JBXL_NET_SOCKET_ERROR ソケットが作成できなかった．
JBXL_NET_OPTION_ERROR オプションの設定に失敗．
JBXL_NET_BIND_ERROR バインドに失敗．
JBXL_NET_INFO_ERROR ホスト情報の取得に失敗．
JBXL_NET_LISTEN_ERROR リッスンに失敗．

Definition at line 490 of file network6.c.

References FALSE, freeNull, itostr_ts(), JBXL_NET_BIND_ERROR, JBXL_NET_INFO_ERROR, JBXL_NET_LISTEN_ERROR, JBXL_NET_OPTION_ERROR, JBXL_NET_SOCKET_ERROR, set_nonblock_socket(), socket_close(), and TRUE.

00491 {
00492     int    sofd, err;
00493     struct addrinfo  hints;
00494     struct addrinfo* address;
00495     int    nonblock = FALSE;
00496  
00497     if (family!=AF_INET && family!=AF_INET6 && family!=AF_UNSPEC) family = AF_UNSPEC;
00498 
00499     memset(&hints, 0, sizeof(struct addrinfo));
00500     hints.ai_family   = family;
00501     hints.ai_flags    = AI_PASSIVE;
00502     hints.ai_socktype = SOCK_STREAM;  
00503 
00504     if (port<0) {
00505         nonblock = TRUE;
00506         port = -port;
00507     }
00508 
00509     char* str = itostr_ts(port);
00510     err = getaddrinfo(NULL, str, &hints, &address);
00511     freeNull(str);
00512     if (err!=0) return JBXL_NET_INFO_ERROR;
00513 
00514     sofd = (int)socket(address->ai_family, address->ai_socktype, address->ai_protocol);
00515     if (sofd<0) {
00516         freeaddrinfo(address);
00517         return JBXL_NET_SOCKET_ERROR;
00518     }
00519     if (nonblock) sofd = set_nonblock_socket(sofd);
00520 
00521     if (opt>0) {
00522         #ifdef WIN32
00523             err = setsockopt(sofd, SOL_SOCKET, opt, (const char*)optval, optlen);
00524         #else
00525             err = setsockopt(sofd, SOL_SOCKET, opt, optval, optlen);
00526         #endif
00527         if (err<0) {
00528             freeaddrinfo(address);
00529             socket_close(sofd);
00530             return JBXL_NET_OPTION_ERROR;
00531         }
00532     }
00533 
00534     err = bind(sofd, address->ai_addr, (int)address->ai_addrlen);
00535     if (err<0) {
00536         freeaddrinfo(address);
00537         socket_close(sofd);
00538         return JBXL_NET_BIND_ERROR;
00539     }
00540 
00541     err = listen(sofd, 10);
00542     if (err==-1) {
00543         freeaddrinfo(address);
00544         socket_close(sofd);
00545         return JBXL_NET_LISTEN_ERROR;
00546     }
00547 
00548     freeaddrinfo(address);
00549     return sofd;
00550 }

Here is the call graph for this function:

int _udp_bind ( int  sofd,
int  port,
int  family 
)

int _udp_bind(int sofd, int port, int family)

UDPソケットにポートをバインドする．

Parameters:
sofd バインドするソケットの記述子．
port ポート番号
family プロトコルファミリー（AF_INET/AF_INET6/AF_UNSPEC)． AF_UNSPEC の場合は先ずIPv6で接続を試み，不可ならIPv4で接続する．
Return values:
0以上 作成されたソケット記述子．
JBXL_NET_BIND_ERROR バインドに失敗．
JBXL_NET_INFO_ERROR ホスト情報の取得に失敗．

Definition at line 288 of file network6.c.

References freeNull, itostr_ts(), JBXL_NET_BIND_ERROR, JBXL_NET_INFO_ERROR, and socket_close().

00289 {
00290     int    err;
00291     struct addrinfo  hints;
00292     struct addrinfo* address;
00293  
00294     if (sofd<=0) return sofd;
00295     if (family!=AF_INET && family!=AF_INET6 && family!=AF_UNSPEC) family = AF_UNSPEC;
00296 
00297     memset(&hints, 0, sizeof(struct addrinfo));
00298     hints.ai_family   = family;
00299     hints.ai_flags    = AI_PASSIVE;
00300     hints.ai_socktype = SOCK_DGRAM;  
00301 
00302     char* str = itostr_ts(port);
00303     err = getaddrinfo(NULL, str, &hints, &address);
00304     freeNull(str);
00305     if (err!=0) return JBXL_NET_INFO_ERROR;
00306  
00307     err = bind(sofd, address->ai_addr, (int)address->ai_addrlen);
00308     if (err<0) {
00309         freeaddrinfo(address);
00310         socket_close(sofd);
00311         return JBXL_NET_BIND_ERROR;
00312     }
00313 
00314     freeaddrinfo(address);
00315     return sofd;
00316 }

Here is the call graph for this function:

int _udp_bind_setopt ( int  sofd,
int  port,
int  opt,
const void *  optval,
int  optlen,
int  family 
)

int _udp_bind_setopt(int sofd, int port, int opt, const void* optval, int optlen, int family)

IPv4/IPv6 のUDPソケットにポートをバインドする．オプションの指定（setsockopt）が可能．

Parameters:
sofd バインドするソケットの記述子．
port ポート番号
opt オプションの種類
optval オプションデータ
optlen optval の長さ
family プロトコルファミリー（AF_INET/AF_INET6/AF_UNSPEC)． AF_UNSPEC の場合は先ずIPv6で接続を試み，不可ならIPv4で接続する．
Return values:
0以上 作成されたソケット記述子．
JBXL_NET_OPTION_ERROR オプションの設定に失敗．
JBXL_NET_BIND_ERROR バインドに失敗．
JBXL_NET_INFO_ERROR ホスト情報の取得に失敗．

Definition at line 338 of file network6.c.

References freeNull, itostr_ts(), JBXL_NET_BIND_ERROR, JBXL_NET_INFO_ERROR, JBXL_NET_OPTION_ERROR, and socket_close().

00339 {
00340     int    err;
00341     struct addrinfo  hints;
00342     struct addrinfo* address;
00343  
00344     if (sofd<=0) return sofd;
00345     if (family!=AF_INET && family!=AF_INET6 && family!=AF_UNSPEC) family = AF_UNSPEC;
00346 
00347     if (opt>0) {
00348         #ifdef WIN32
00349             err = setsockopt(sofd, SOL_SOCKET, opt, (const char*)optval, optlen);
00350         #else
00351             err = setsockopt(sofd, SOL_SOCKET, opt, optval, optlen);
00352         #endif
00353         if (err<0) {
00354             socket_close(sofd);
00355             return JBXL_NET_OPTION_ERROR;
00356         } 
00357     }
00358 
00359     memset(&hints, 0, sizeof(struct addrinfo));
00360     hints.ai_family   = family;
00361     hints.ai_flags    = AI_PASSIVE;
00362     hints.ai_socktype = SOCK_DGRAM;  
00363 
00364     char* str = itostr_ts(port);
00365     err = getaddrinfo(NULL, str, &hints, &address);
00366     freeNull(str);
00367     if (err!=0) {
00368         socket_close(sofd);
00369         return JBXL_NET_INFO_ERROR;
00370     }
00371  
00372     err = bind(sofd, address->ai_addr, (int)address->ai_addrlen);
00373     if (err<0) {
00374         freeaddrinfo(address);
00375         socket_close(sofd);
00376         return JBXL_NET_BIND_ERROR;
00377     }
00378 
00379     freeaddrinfo(address);
00380     return sofd;
00381 }

Here is the call graph for this function:

int _udp_client_socket ( char *  hostname,
int  port,
struct addrinfo **  sv_addr,
int  family 
)

int _udp_client_socket(char* hostname, int port, struct addrinfo** sv_addr, int family)

UDPのクライアントソケットを作る． 正常終了した場合, *sv_addrにサーバの情報が格納される．

この関数内で呼び出されるネットワーク関数: socket(), getaddrinfo()

Parameters:
hostname サーバ名
port サーバポート番号
sv_addr addrinfo 構造体へのポインタへのポインタが返る．要 freeaddrinfo(*sv_addr)
family プロトコルファミリー（AF_INET/AF_INET6/AF_UNSPEC)． AF_UNSPEC の場合は先ずIPv6で接続を試み，不可ならIPv4で接続する．
Return values:
0以上 作成されたソケット記述子．
JBXL_NET_SOCKET_ERROR ソケットが作成できなかった．
JBXL_NET_INFO_ERROR ホスト情報の取得に失敗．

Definition at line 241 of file network6.c.

References freeNull, itostr_ts(), JBXL_NET_INFO_ERROR, and JBXL_NET_SOCKET_ERROR.

00242 {
00243     int    sofd, err;
00244     struct addrinfo  hints;
00245  
00246     if (sv_addr==NULL) return JBXL_NET_INFO_ERROR;
00247     if (family!=AF_INET && family!=AF_INET6 && family!=AF_UNSPEC) family = AF_UNSPEC;
00248 
00249     memset(&hints, 0, sizeof(struct addrinfo));
00250     hints.ai_family   = family;
00251     hints.ai_flags    = AI_PASSIVE; // 任意のIPアドレスの接続を許す設定．本来はサーバ用．多分不必要（無視される）．
00252     hints.ai_socktype = SOCK_DGRAM;  
00253  
00254     char* str = itostr_ts(port);
00255     err = getaddrinfo(hostname, str, &hints, sv_addr);
00256     freeNull(str);
00257     if (err!=0) {
00258         *sv_addr = NULL;
00259         return JBXL_NET_INFO_ERROR;
00260     }
00261 
00262     sofd = (int)socket((*sv_addr)->ai_family, (*sv_addr)->ai_socktype, (*sv_addr)->ai_protocol);
00263     if (sofd<0) {
00264         freeaddrinfo(*sv_addr);
00265         *sv_addr = NULL;
00266         return JBXL_NET_SOCKET_ERROR;
00267     }
00268 
00269     return sofd;
00270 }

Here is the call graph for this function:

int _udp_server_socket ( int  port,
struct addrinfo **  sv_addr,
int  family 
)

int _udp_server_socket(int port, struct addrinfo** sv_addr, int family)

IPv4/IPv6 の UDPサーバソケットを作り,接続待ち状態になる．

この関数内で呼び出されるネットワーク関数: socket(), bind()

Parameters:
port ポート番号
sv_addr addrinfo 構造体へのポインタへのポインタが返る．要 freeaddrinfo(*sv_addr)
family プロトコルファミリー（AF_INET/AF_INET6/AF_UNSPEC)． AF_UNSPEC の場合は先ずIPv6で接続を試み，不可ならIPv4で接続する．
Return values:
0以上 作成されたソケット記述子．
JBXL_NET_SOCKET_ERROR ソケットが作成できなかった．
JBXL_NET_BIND_ERROR バインドに失敗．
JBXL_NET_INFO_ERROR ホスト情報の取得に失敗．

Definition at line 72 of file network6.c.

References FALSE, freeNull, itostr_ts(), JBXL_NET_BIND_ERROR, JBXL_NET_INFO_ERROR, JBXL_NET_OPTION_ERROR, JBXL_NET_SOCKET_ERROR, OFF, ON, set_nonblock_socket(), socket_close(), and TRUE.

00073 {
00074     int    sofd, err, nullflg = OFF;
00075     struct addrinfo  hints;
00076     struct addrinfo* address;
00077     int    nonblock = FALSE;
00078 
00079     if (sv_addr==NULL) {
00080         nullflg = ON;
00081         sv_addr = &address;
00082     }
00083     if (family!=AF_INET && family!=AF_INET6 && family!=AF_UNSPEC) family = AF_UNSPEC;
00084     //
00085     if (port<0) {
00086         nonblock = TRUE;
00087         port = -port;
00088     }
00089 
00090     memset(&hints, 0, sizeof(struct addrinfo));
00091     hints.ai_family   = family;
00092     hints.ai_flags    = AI_PASSIVE; // 任意のIPアドレスの接続を許す設定．サーバ用．
00093     hints.ai_socktype = SOCK_DGRAM;  
00094 
00095     char* str = itostr_ts(port);
00096     err = getaddrinfo(NULL, str, &hints, sv_addr);
00097     freeNull(str);
00098     if (err!=0) {
00099         *sv_addr = NULL;
00100         return JBXL_NET_INFO_ERROR;
00101     }
00102 
00103     sofd = (int)socket((*sv_addr)->ai_family, (*sv_addr)->ai_socktype, (*sv_addr)->ai_protocol);
00104     if (sofd<0) {
00105         freeaddrinfo(*sv_addr);
00106         *sv_addr = NULL;
00107         return JBXL_NET_SOCKET_ERROR;
00108     }
00109     if (nonblock) sofd = set_nonblock_socket(sofd);
00110  
00111     // TIME_WAIT しない設定．
00112     int lg = 1;
00113     #ifdef WIN32
00114         err = setsockopt(sofd, SOL_SOCKET, SO_REUSEADDR, (const char*)&lg, sizeof(lg));
00115     #else
00116         err = setsockopt(sofd, SOL_SOCKET, SO_REUSEADDR, &lg, sizeof(lg));
00117     #endif
00118     if (err<0) {
00119         freeaddrinfo(*sv_addr);
00120         socket_close(sofd);
00121         return JBXL_NET_OPTION_ERROR;
00122     } 
00123 
00124     err = bind(sofd, (*sv_addr)->ai_addr, (int)(*sv_addr)->ai_addrlen);
00125     if (err<0) {
00126         freeaddrinfo(*sv_addr);
00127         *sv_addr = NULL;
00128         socket_close(sofd);
00129         return JBXL_NET_BIND_ERROR;
00130     }
00131 
00132     if (nullflg) freeaddrinfo(*sv_addr);
00133     return sofd;
00134 }

Here is the call graph for this function:

int _udp_server_socket_setopt ( int  port,
int  opt,
const void *  optval,
int  optlen,
struct addrinfo **  sv_addr,
int  family 
)

int _udp_server_socket_setopt(int port, int opt, const void* optval, int optlen, struct addrinfo** sv_addr, int family)

IPv4/IPv6 の UDPサーバソケットを作り,接続待ち状態になる．オプションの指定（setsockopt）が可能．

この関数内で呼び出されるネットワーク関数: socket(), setsockopt(), bind()

Parameters:
port ポート番号
opt オプションの種類
optval オプションデータ
optlen optval の長さ
sv_addr addrinfo 構造体へのポインタへのポインタが返る．要 freeaddrinfo(*sv_addr)
family プロトコルファミリー（AF_INET/AF_INET6/AF_UNSPEC)． AF_UNSPEC の場合は先ずIPv6で接続を試み，不可ならIPv4で接続する．
Return values:
0以上 作成されたソケット記述子．
JBXL_NET_SOCKET_ERROR ソケットが作成できなかった．
JBXL_NET_OPTION_ERROR オプションの設定に失敗．
JBXL_NET_BIND_ERROR バインドに失敗．
JBXL_NET_INFO_ERROR ホスト情報の取得に失敗．

Definition at line 159 of file network6.c.

References FALSE, freeNull, itostr_ts(), JBXL_NET_BIND_ERROR, JBXL_NET_INFO_ERROR, JBXL_NET_OPTION_ERROR, JBXL_NET_SOCKET_ERROR, OFF, ON, set_nonblock_socket(), socket_close(), and TRUE.

00160 {
00161     int    sofd, err, nullflg = OFF;
00162     struct addrinfo  hints;
00163     struct addrinfo* address;
00164     int    nonblock = FALSE;
00165 
00166     if (sv_addr==NULL) {
00167         nullflg = ON;
00168         sv_addr = &address;
00169     }
00170     if (family!=AF_INET && family!=AF_INET6 && family!=AF_UNSPEC) family = AF_UNSPEC;
00171     //
00172     if (port<0) {
00173         nonblock = TRUE;
00174         port = -port;
00175     }
00176 
00177     memset(&hints, 0, sizeof(struct addrinfo));
00178     hints.ai_family   = family;
00179     hints.ai_flags    = AI_PASSIVE;
00180     hints.ai_socktype = SOCK_DGRAM;  
00181 
00182     char* str = itostr_ts(port);
00183     err = getaddrinfo(NULL, str, &hints, sv_addr);
00184     freeNull(str);
00185     if (err!=0) return JBXL_NET_INFO_ERROR;
00186 
00187     sofd = (int)socket((*sv_addr)->ai_family, (*sv_addr)->ai_socktype, (*sv_addr)->ai_protocol);
00188     if (sofd<0) {
00189         freeaddrinfo(*sv_addr);
00190         *sv_addr = NULL;
00191         return JBXL_NET_SOCKET_ERROR;
00192     }
00193     if (nonblock) sofd = set_nonblock_socket(sofd);
00194  
00195     if (opt>0) {
00196         #ifdef WIN32
00197             err = setsockopt(sofd, SOL_SOCKET, opt, (const char*)optval, optlen);
00198         #else
00199             err = setsockopt(sofd, SOL_SOCKET, opt, optval, optlen);
00200         #endif
00201         if (err<0) {
00202             freeaddrinfo(*sv_addr);
00203             *sv_addr = NULL;
00204             socket_close(sofd);
00205             return JBXL_NET_OPTION_ERROR;
00206         } 
00207     }
00208  
00209     err = bind(sofd, (*sv_addr)->ai_addr, (int)(*sv_addr)->ai_addrlen);
00210     if (err<0) {
00211         freeaddrinfo(*sv_addr);
00212         *sv_addr = NULL;
00213         socket_close(sofd);
00214         return JBXL_NET_BIND_ERROR;
00215     }
00216 
00217     if (nullflg) freeaddrinfo(*sv_addr);
00218     return sofd;
00219 }

Here is the call graph for this function:

int accept_intr ( int  sock,
struct sockaddr *  cl_addr,
socklen_t *  cdlen 
)

int accept_intr(int sock, struct sockaddr* cl_addr, socklen_t* cdlen)

accept()でブロック中に割り込みが掛かって，accept()が失敗で終了しても 再施行できるようにするためのラッパー関数 (for Solaris)

Parameters:
sock ソケット
cl_addr ソケットの情報が入る sockaddr 構造体へのポインタ
cdlen sockaddr 構造体（*cl_addr）のサイズ
Return values:
0以上 accept() で作成されたソケット記述子．
-1 エラー．

Definition at line 1011 of file network6.c.

01012 {
01013     int nsofd = 0;
01014 
01015     do {
01016         nsofd = (int)accept(sock, cl_addr, cdlen);
01017     } while (nsofd==-1 && errno==EINTR);
01018 
01019     //if (nsofd<0) Error("accept_intr");
01020 
01021     return nsofd;
01022 }

void cleanup_network ( void   ) 

Definition at line 41 of file network6.c.

00042 {
00043 #ifdef WIN32
00044     WSACleanup();
00045 #endif
00046 }

char* get_hostname_bynum ( unsigned char *  num,
int  family 
)

char* get_hostname_bynum(unsigned char* num, int family)

IPv4/IPv6 アドレス（バイナリ）からホスト名を逆引きする．

Parameters:
num IPv4/IPv6 アドレス（バイナリ）
family アドレスファミリー（AF_INET/AF_INET6）
Returns:
ホスト名（文字列）．要 free

Definition at line 1672 of file network6.c.

References LNAME, and make_sockaddr_bynum().

01673 {
01674     int   len, err;
01675     char  htemp[LNAME];
01676     char* hname = NULL;
01677     struct sockaddr* sa;
01678 
01679     if (num==NULL) return NULL;
01680     if (family!=AF_INET6) family = AF_INET6;
01681 
01682     sa = make_sockaddr_bynum(num, 0, family);
01683     if (sa==NULL) return NULL;
01684 
01685     if (family==AF_INET6) len = sizeof(struct sockaddr_in6);
01686     else                  len = sizeof(struct sockaddr_in);
01687     err = getnameinfo(sa, len, htemp, LNAME-1, NULL, 0, 0);
01688     if (err!=0) {
01689         free(sa);
01690         return NULL;
01691     }
01692 
01693     len = (int)strlen(htemp);
01694     hname = (char*)malloc(len+1);
01695     if (hname==NULL) {
01696         free(sa);
01697         return NULL;
01698     }
01699 
01700     free(sa);
01701     memcpy(hname, htemp, len+1);
01702     return hname;    
01703 }

Here is the call graph for this function:

char* get_hostname_bystr ( const char *  addr  ) 

char* get_hostname_bystr(const char* addr)

IPv4/IPv6 アドレス（文字列）からホスト名を逆引きする．

Parameters:
addr IPv4/IPv6 アドレス（文字列）
Returns:
ホスト名（文字列）．要 free

Definition at line 1715 of file network6.c.

References LNAME, and make_sockaddr_bystr().

01716 {
01717     int   len, err;
01718     char  htemp[LNAME];
01719     char* hname = NULL;
01720     struct sockaddr* sa;
01721 
01722     if (addr==NULL) return NULL;
01723 
01724     sa = make_sockaddr_bystr(addr, 0);
01725     if (sa==NULL) return NULL;
01726 
01727     if (sa->sa_family==AF_INET6) len = sizeof(struct sockaddr_in6);
01728     else                         len = sizeof(struct sockaddr_in);
01729     err = getnameinfo(sa, len, htemp, LNAME-1, NULL, 0, 0);
01730     if (err!=0) {
01731         free(sa);
01732         return NULL;
01733     }
01734 
01735     len = (int)strlen(htemp);
01736     hname = (char*)malloc(len+1);
01737     if (hname==NULL) {
01738         free(sa);
01739         return NULL;
01740     }
01741 
01742     free(sa);
01743     memcpy(hname, htemp, len+1);
01744     return hname;    
01745 }

Here is the call graph for this function:

char* get_ipaddr_byname ( const char *  hostname,
int  family 
)

char* get_ipaddr_byname(const char* hostname, int family)

ホスト名から IPv4/IPv6 アドレス（文字列）を獲得する．

Parameters:
hostname ホスト名
family IPのアドレスファミリー AF_INET/AF_INET6
Returns:
IPv4/IPv6 アドレス（文字列）へのポインタ．要 free

Definition at line 1814 of file network6.c.

References get_ipaddr_byname_num(), LEN_IPADDR, and LEN_IPADDR6.

01815 {
01816     int   len;
01817     char* ip;
01818     unsigned char* ipnum;
01819 
01820     if (family!=AF_INET6) family = AF_INET;
01821 
01822     ipnum = get_ipaddr_byname_num(hostname, family);   // 4Byte or 16Byte
01823     if (ipnum==NULL) return NULL;
01824 
01825     if (family==AF_INET6) len = LEN_IPADDR6;
01826     else                  len = LEN_IPADDR;
01827     ip = (char*)malloc(len);
01828     if (ip==NULL) return NULL;
01829     memset(ip, 0, len);
01830         
01831     inet_ntop(family, ipnum, ip, len);
01832     free(ipnum);
01833     return ip;
01834 }

Here is the call graph for this function:

unsigned char* get_ipaddr_byname_num ( const char *  hostname,
int  family 
)

unsigned char* get_ipaddr_byname_num(const char* hostname, int family)

ホスト名から IPv4/IPv6 アドレス（バイナリ）を獲得する．

Parameters:
hostname ホスト名
family IPのアドレスファミリー AF_INET/AF_INET6
Returns:
IPv4/IPv6 アドレス（バイナリ）へのポインタ（長さ 4/16Byte）．要 free

Definition at line 1847 of file network6.c.

01848 {
01849     int err;
01850     struct addrinfo  hints;
01851     struct addrinfo* address;
01852     unsigned char* ip = NULL;
01853     unsigned char* pp = NULL;
01854 
01855     if (family!=AF_INET6) family = AF_INET;
01856 
01857     memset(&hints, 0, sizeof(struct addrinfo));
01858     hints.ai_socktype = SOCK_STREAM;
01859     hints.ai_family   = family;
01860 
01861     err = getaddrinfo(hostname, NULL, &hints, &address); 
01862     if (err!=0 || address==NULL) return NULL;
01863 
01864     if (family==AF_INET6) {  // IPv6
01865         ip = (unsigned char*)malloc(16);
01866         if (ip!=NULL) {
01867             //pp = (unsigned char*)(((struct sockaddr_in6*)(address->ai_addr))->sin6_addr.s6_addr);  // unsigned char s6_addr[16]; 
01868             pp = (unsigned char*)&(((struct sockaddr_in6*)(address->ai_addr))->sin6_addr);  // unsigned char s6_addr[16]; 
01869             memcpy(ip, pp, 16);
01870         }
01871     }
01872     //
01873     if (pp==NULL) {         // IPv4
01874         ip = (unsigned char*)malloc(4);
01875         if (ip!=NULL) {
01876             //pp = (unsigned char*)(&((struct sockaddr_in*)(address->ai_addr))->sin_addr.s_addr);    // ulong s_addr; 
01877             pp = (unsigned char*)&(((struct sockaddr_in*)(address->ai_addr))->sin_addr);    // ulong s_addr; 
01878             memcpy(ip, pp, 4);
01879         }
01880     }
01881 
01882     freeaddrinfo(address);
01883     return ip;
01884 }

char* get_ipaddr_ipv4 ( struct in_addr  sin_addr  ) 

char* get_ipaddr_ipv4(struct in_addr sin_addr)

in_addr構造体から IPアドレスを獲得する．

Parameters:
sin_addr sockaddr_in 構造体の sin_addr メンバ．
Returns:
IPアドレス(文字列)へのポインタ．要 free
   struct sockaddr_in addr
   .........;
   ipaddr = get_ipaddr_ipv4(addr.sin_addr);

Definition at line 2735 of file network6.c.

02736 {
02737     char* ip;
02738     unsigned char* pp;
02739 
02740     pp = (unsigned char*)&(sin_addr);
02741     if (pp[0]==0) return NULL;
02742 
02743     ip = (char*)malloc(16);
02744     if (ip==NULL) return NULL;
02745     memset(ip, 0, 16);
02746 
02747     snprintf(ip, 15, "%d.%d.%d.%d", pp[0], pp[1], pp[2], pp[3]);
02748 
02749     return ip;
02750 }

unsigned char* get_ipaddr_num_ipv4 ( struct in_addr  sin_addr  ) 

unsigned char* get_ipaddr_num_ipv4(struct in_addr sin_addr)

in_addr 構造体から IPアドレスを獲得する．

Parameters:
sin_addr sockaddr_in 構造体の sin_addr メンバ．
Returns:
IPアドレス(バイナリ)へのポインタ（長さ4byte）．要 free
    struct sockaddr_in addr
    .........;
    ipaddr = get_ipaddr_num(addr.sin_addr);

Definition at line 2768 of file network6.c.

02769 {
02770     unsigned char* ip;
02771     unsigned char* pp;
02772 
02773     ip = (unsigned char*)malloc(4);
02774     if (ip==NULL) return NULL;
02775 
02776     pp = (unsigned char*)&(sin_addr);
02777     memcpy(ip, pp, 4);
02778 
02779     return ip;
02780 }

struct sockaddr_in get_local_sockaddr_in ( unsigned short  cport  )  [read]

Definition at line 2703 of file network6.c.

02704 {
02705     struct sockaddr_in  ss_addr;
02706     struct hostent *shost;
02707 
02708     // localhost の情報を ss_addrに格納
02709     shost = gethostbyname("127.0.0.1");
02710 
02711     memset(&ss_addr, 0, sizeof(ss_addr));
02712     ss_addr.sin_family = AF_INET;
02713     ss_addr.sin_port   = htons(cport);
02714     memcpy(&(ss_addr.sin_addr), shost->h_addr, shost->h_length);
02715 
02716     return ss_addr;
02717 }

char* get_myipaddr ( int  family  ) 

Definition at line 1969 of file network6.c.

References LNAME, OFF, and ON.

01970 {
01971     int    err, flg, len, lst;
01972     struct ifaddrs *if_addr;
01973     struct ifaddrs *ifap;
01974 
01975     char  htemp[LNAME];
01976     char* haddr = NULL;
01977 
01978     if (family!=AF_INET6) {
01979         family = AF_INET;
01980          len = sizeof(struct sockaddr_in);
01981     }
01982     else {
01983          len = sizeof(struct sockaddr_in6);
01984     }
01985     //
01986     err = getifaddrs(&if_addr);
01987     if (err<0) return NULL;
01988 
01989     flg  = OFF;
01990     ifap = if_addr;
01991     while(ifap!=NULL) {
01992         if (ifap->ifa_addr!=NULL && family==ifap->ifa_addr->sa_family) {
01993             memset(htemp, 0, LNAME);
01994             err = getnameinfo(ifap->ifa_addr, len, htemp, LNAME, NULL, 0, NI_NUMERICHOST);
01995             if (err==0) {
01996                 if (family==AF_INET) {
01997                     if (strncmp(htemp, "127.0.0.1", 9) && strncmp(htemp, "169.254.", 8)) {
01998                         struct sockaddr_in* sa = (struct sockaddr_in*)(ifap->ifa_addr);
01999                         unsigned char check = ((unsigned char*)&(sa->sin_addr))[0] & 0xf0;
02000                         if (check != 0xe) { // not multi cast
02001                             flg = ON;
02002                             break;
02003                         }
02004                     }
02005                 }
02006                 else {
02007                     if (strncmp(htemp, "::1", 3) && strncasecmp(htemp, "fe80:", 5)) {
02008                         flg = ON;
02009                         break;
02010                     }
02011                 }
02012             }
02013         }
02014         ifap=ifap->ifa_next;
02015     }
02016     if (flg==OFF) {
02017         freeifaddrs(if_addr);
02018         return NULL;
02019     }
02020     
02021     freeifaddrs(if_addr);
02022 
02023     lst = strlen(htemp);
02024     if (LNAME-lst-1<=0) return NULL;
02025     htemp[lst++] = '/';
02026 
02027     err = getnameinfo(ifap->ifa_netmask, len, &(htemp[lst]), LNAME-lst, NULL, 0, NI_NUMERICHOST);
02028     if (err!=0) return NULL;
02029 
02030     len = strlen(htemp) + 1;
02031     haddr = (char*)malloc(len);
02032     if (haddr==NULL) return NULL;
02033     memset(haddr, 0, len);
02034     memcpy(haddr, htemp, len-1);
02035 
02036     return haddr;    
02037 }

unsigned char* get_myipaddr_num ( int  family  ) 

Definition at line 2043 of file network6.c.

References get_myipaddr().

02044 {
02045     int   len, err;
02046     char* pos;
02047     char* htemp;
02048     unsigned char* haddr = NULL;
02049 
02050     if (family!=AF_INET6) family = AF_INET;
02051 
02052     //
02053     htemp = get_myipaddr(family);
02054     if (htemp==NULL) return NULL;
02055 
02056     pos = strstr(htemp, "/");
02057     if (pos==NULL) {
02058         free(htemp);
02059         return NULL;
02060     }
02061     *pos = '\0';
02062 
02063     if (family==AF_INET6) len = 16;
02064     else                  len = 4;
02065     haddr = (unsigned char*)malloc(len*2);
02066     if (haddr==NULL) {
02067         free(htemp);
02068         return NULL;
02069     }
02070 
02071     err = inet_pton(family, htemp, haddr);
02072     if (err!=1) {
02073         free(haddr);
02074         return NULL;
02075     }
02076 
02077     err = inet_pton(family, pos+1, haddr+len);
02078     free(htemp);
02079     if (err!=1) {
02080         free(haddr);
02081         return NULL;
02082     }
02083 
02084     return haddr;    
02085 }

Here is the call graph for this function:

char* get_mynetaddr ( int  family  ) 

char* get_mynetaddr(int family)

自分のネットワークアドレスを返す

Parameters:
family プロトコルファミリー（AF_INET/AF_INET6)
Returns:
ネットワークアドレス(文字列)へのポインタ．要 free

Definition at line 2177 of file network6.c.

References get_mynetaddr_num(), LEN_IPADDR, and LEN_IPADDR6.

02178 {
02179     int  len;
02180     char* net;
02181     unsigned char* pp;
02182 
02183     len = LEN_IPADDR6;
02184     if (family!=AF_INET6) {
02185         len = LEN_IPADDR;
02186         family = AF_INET;
02187     }
02188 
02189     pp = get_mynetaddr_num(family);
02190     if (pp==NULL) return NULL;
02191 
02192     net = (char*)malloc(len);
02193     if (net==NULL) {
02194         free(pp);
02195         return NULL;
02196     }
02197     memset(net, 0, len);
02198 
02199     inet_ntop(family, pp, net, len);
02200     free(pp);
02201     return net;
02202 }

Here is the call graph for this function:

unsigned char* get_mynetaddr_num ( int  family  ) 

unsigned char* get_mynetaddr_num(int family)

自分のネットワークアドレスを返す

Returns:
ネットワークアドレス(バイナリ)へのポインタ（長さ4byte）．要 free

Definition at line 2213 of file network6.c.

References get_myipaddr_num().

02214 {
02215     int  i, len;
02216     unsigned char* net;
02217     unsigned char* ip;
02218     unsigned char* mk;
02219         
02220     len = 16;
02221     if (family!=AF_INET6) len = 4;
02222 
02223     ip = get_myipaddr_num(family);
02224     if (ip==NULL) return NULL;
02225     mk = &(ip[len]);
02226 
02227     net = (unsigned char*)malloc(len);
02228     if (net==NULL) {
02229         free(ip);
02230         return NULL;
02231     }
02232 
02233     for (i=0; i<len; i++) net[i] = ip[i] & mk[i];
02234 
02235     free(ip);
02236     return net;
02237 }

Here is the call graph for this function:

struct sockaddr_in get_sockaddr_in ( char *  hostname,
unsigned short  cport 
) [read]

Definition at line 2666 of file network6.c.

02667 {
02668     struct sockaddr_in  ss_addr;
02669     struct hostent *shost;
02670 
02671     // Serverの情報を ss_addrに格納
02672     shost = gethostbyname(hostname);
02673     if (shost==NULL) {
02674         ss_addr.sin_family = 0;
02675         ss_addr.sin_port   = 0;
02676         return ss_addr;
02677     }
02678 
02679     memset(&ss_addr, 0, sizeof(ss_addr));
02680     ss_addr.sin_family = AF_INET;
02681     ss_addr.sin_port   = htons(cport);
02682     memcpy(&(ss_addr.sin_addr), shost->h_addr, shost->h_length);
02683 
02684     return ss_addr;
02685 }

struct sockaddr_in get_sockaddr_in_bynum ( char *  ipnum,
unsigned short  cport 
) [read]

Definition at line 2689 of file network6.c.

02690 {
02691     struct sockaddr_in  ss_addr;
02692 
02693     memset(&ss_addr, 0, sizeof(ss_addr));
02694     ss_addr.sin_family = AF_INET;
02695     ss_addr.sin_port   = htons(cport);
02696     memcpy(&(ss_addr.sin_addr), ipnum, 4);
02697 
02698     return ss_addr;
02699 }

int get_valid_tcp_client_socket ( int  min,
int  max,
char *  hname,
unsigned short  sport,
unsigned short *  cport 
)

Definition at line 1140 of file network6.c.

References tcp_client_bind_socket.

01141 {
01142     int  i, sock, range;
01143 
01144     range  = max - min + 1;
01145     *cport = rand()%range + min;
01146 
01147     i = 1;
01148     sock = tcp_client_bind_socket(hname, (int)sport, (int)*cport);
01149     while(sock<0 && i<range) {
01150         (*cport)++;
01151         if (*cport>max) *cport = ((int)*cport)%max + min - 1;
01152         sock = tcp_client_bind_socket(hname, (int)sport, (int)*cport);
01153         i++;
01154     }
01155 
01156     if (sock<=0) *cport = 0;
01157 
01158     return sock;
01159 }

int get_valid_tcp_server_socket ( int  min,
int  max,
unsigned short *  port 
)

Definition at line 1118 of file network6.c.

References tcp_server_socket.

01119 {
01120     int  i, sock, range;
01121 
01122     range = max - min + 1;
01123     *port = rand()%range + min;
01124 
01125     i = 1;
01126     sock = tcp_server_socket((int)*port);
01127     while(sock<=0 && i<range) {
01128         (*port)++;
01129         if (*port>max) *port = ((int)*port)%max + min - 1;
01130         sock = tcp_server_socket((int)*port);
01131         i++;
01132     }
01133 
01134     if (sock<=0) *port = 0;
01135 
01136     return sock;
01137 }

int get_valid_udp_socket ( int  min,
int  max,
unsigned short *  port 
)

Definition at line 1094 of file network6.c.

References udp_server_socket.

01095 {
01096     int  i, sock, range;
01097     struct addrinfo* address;
01098 
01099     range = max - min + 1;
01100     *port = rand()%range + min;
01101 
01102     i = 1;
01103     sock = udp_server_socket((int)*port, &address);
01104     while(sock<=0 && i<range) {
01105         (*port)++;
01106         if (*port>max) *port = ((int)*port)%max + min - 1;
01107         sock = udp_server_socket((int)*port, &address);
01108         i++;
01109     }
01110 
01111     if (sock<=0) *port = 0;
01112 
01113     freeaddrinfo(address);
01114     return sock;
01115 }

int init_network ( void   ) 

Definition at line 27 of file network6.c.

00028 {
00029     int ret = 0;
00030 
00031 #ifdef WIN32
00032     // for 10093 エラー
00033     ret = WSAStartup(MAKEWORD(2,0), &WsaData);
00034     if (ret!=0) WSACleanup();
00035 #endif
00036 
00037     return ret;
00038 }

int is_same_network ( char *  addr1,
char *  addr2,
char *  mask 
)

int is_same_network(char* addr1, char* addr2, char* mask)

文字型アドレス addr1 と addr2が同じネットワークに属しているかどうかチェックする．
addr1, addr2 は FQDNでも可．

Parameters:
addr1 比較するアドレス（文字型）．FQDN は不可
addr2 比較するアドレス（文字型）．FQDN は不可
mask ネットマスク（文字型）
Return values:
TRUE 同じネットワークである．
FALSE 同じネットワークでない．

Definition at line 2322 of file network6.c.

References FALSE, freeNull, is_same_network_num(), and to_address_num().

02323 {
02324     int  ret, family;
02325     unsigned char* a1;
02326     unsigned char* a2;
02327     unsigned char* mk;
02328 
02329     if (addr1==NULL || addr2==NULL || mask==NULL) return FALSE;
02330 
02331     a1 = (unsigned char*)strstr(addr1, ":");
02332     a2 = (unsigned char*)strstr(addr1, ":");
02333     mk = (unsigned char*)strstr(mask,  ":");
02334     if      (a1!=NULL && a2!=NULL && mask!=NULL)  family = AF_INET6;
02335     else if (a1==NULL && a2==NULL && mask==NULL)  family = AF_INET;
02336     else return FALSE;
02337 
02338     a1 = to_address_num(addr1, 0, 0, family);
02339     a2 = to_address_num(addr2, 0, 0, family);
02340     mk = to_address_num(mask,  0, 0, family);
02341     if (a1==NULL || a2==NULL || mk==NULL) {
02342         freeNull(a1);
02343         freeNull(a2);
02344         freeNull(mk);
02345         return FALSE;
02346     }
02347 
02348     ret = is_same_network_num(a1, a2, mk, family);
02349     freeNull(a1);
02350     freeNull(a2);
02351     freeNull(mk);
02352     
02353     return ret;
02354 }

Here is the call graph for this function:

int is_same_network_num ( unsigned char *  addr1,
unsigned char *  addr2,
unsigned char *  mask,
int  family 
)

int is_same_network_num(unsigned char* addr1, unsigned char* addr2, unsigned char* mask, int family)

数字型アドレス addr1 と addr2が同じネットワークに属しているかどうかチェックする．

Parameters:
addr1 比較するアドレス（数字型）4/16Byte
addr2 比較するアドレス（数字型）4/16Byte
mask ネットマスク（数字型）4/16Byte
family アドレスファミリー (AF_INET/AF_INET6)
Return values:
TRUE 同じネットワークである．
FALSE 同じネットワークでない

Definition at line 2371 of file network6.c.

References FALSE, and TRUE.

02372 {
02373     int i, len;
02374 
02375     if (addr1==NULL || addr2==NULL) return FALSE;
02376 
02377     len = 16;
02378     if (family!=AF_INET6) len = 4;
02379 
02380     if (mask==NULL) {
02381         for (i=0; i<len; i++) {
02382             if (addr1[i] != addr2[i]) return FALSE;
02383         }
02384     }
02385     else {
02386         for (i=0; i<len; i++) {
02387             if ((addr1[i] & mask[i]) != (addr2[i] & mask[i])) return FALSE;
02388         }
02389     }
02390     return TRUE;
02391 }

int is_same_sockaddr ( struct sockaddr *  addr1,
struct sockaddr *  addr2 
)

int is_same_sockaddr(struct sockaddr* addr1, struct sockaddr* addr2)

addr1 と addr2が格納する IPアドレスとポート番号が同じかどうか検査する

Parameters:
addr1 比較する sockaddr 構造体へのポインタ
addr2 比較する sockaddr 構造体へのポインタ
Return values:
TRUE 同じホスト
FALSE 違うホスト

Definition at line 2257 of file network6.c.

References FALSE, and TRUE.

02258 {
02259     int  i, len;
02260     unsigned char       *p1,   *p2;
02261     struct sockaddr_in  *sa1,  *sa2;
02262     struct sockaddr_in6 *sa61, *sa62;
02263 
02264     if (addr1==NULL || addr2==NULL) return FALSE;
02265     if (addr1->sa_family!=addr2->sa_family) return FALSE;
02266 
02267     if (addr1->sa_family==AF_INET) {
02268         sa1 = (struct sockaddr_in*)addr1;
02269         sa2 = (struct sockaddr_in*)addr2;
02270 
02271         p1  = (unsigned char*)&(sa1->sin_addr);
02272         p2  = (unsigned char*)&(sa2->sin_addr);
02273         len = sizeof(sa1->sin_addr);
02274         for (i=0; i<len; i++) {
02275             if (p1[i]!=p2[i]) return FALSE;
02276         }
02277 
02278         p1  = (unsigned char*)&(sa1->sin_port);
02279         p2  = (unsigned char*)&(sa2->sin_port);
02280         len = sizeof(sa1->sin_port);
02281         for (i=0; i<len; i++) {
02282             if (p1[i]!=p2[i]) return FALSE;
02283         }
02284     }
02285     else {
02286         sa61 = (struct sockaddr_in6*)addr1;
02287         sa62 = (struct sockaddr_in6*)addr2;
02288 
02289         p1  = (unsigned char*)&(sa61->sin6_addr);
02290         p2  = (unsigned char*)&(sa62->sin6_addr);
02291         len = sizeof(sa61->sin6_addr);
02292         for (i=0; i<len; i++) {
02293             if (p1[i]!=p2[i]) return FALSE;
02294         }
02295 
02296         p1  = (unsigned char*)&(sa61->sin6_port);
02297         p2  = (unsigned char*)&(sa62->sin6_port);
02298         len = sizeof(sa61->sin6_port);
02299         for (i=0; i<len; i++) {
02300             if (p1[i]!=p2[i]) return FALSE;
02301         }
02302     }
02303 
02304     return TRUE;
02305 }

struct sockaddr* make_sockaddr_bynum ( unsigned char *  addr,
int  port,
int  family 
) [read]

struct sockaddr* make_sockaddr_bynum(unsigned char* addr, int port, int family)

バイナリの IPv4/IPv6 アドレスとポート番号から 有効な struct sockaddr を作り出す

Parameters:
addr バイナリのIPアドレス（IPv4/IPv6）
port ポート番号
family プロトコルファミリー（AF_INET/AF_INET6)
Returns:
sa struct sockaddr へのポインタ．要 free

Definition at line 1584 of file network6.c.

01585 {
01586     struct sockaddr* sa = NULL;
01587     int len;
01588 
01589     len = sizeof(struct sockaddr);
01590     sa  = (struct sockaddr*)malloc(len);
01591     if (sa==NULL) return NULL;
01592     memset(sa, 0, len);
01593 
01594     if (family==AF_INET6) {     // IPv6
01595         struct sockaddr_in6* sa6;
01596         len = sizeof(struct sockaddr_in6);
01597         sa6 = (struct sockaddr_in6*)malloc(len);
01598         memset(sa6, 0, len);
01599         //
01600         sa6->sin6_family = AF_INET6;
01601         sa6->sin6_port   = htons(port);
01602         //memcpy(sa6->sin6_addr.s6_addr, addr, 16);
01603         memcpy(&(sa6->sin6_addr), addr, 16);
01604         sa = (struct sockaddr*)sa6;
01605     }
01606     //
01607     else {                      // IPv4
01608         struct sockaddr_in* sa4;
01609         len = sizeof(struct sockaddr_in);
01610         sa4 = (struct sockaddr_in*)malloc(len);
01611         memset(sa4, 0, len);
01612         //
01613         sa4->sin_family = AF_INET;
01614         sa4->sin_port   = htons(port);
01615         //memcpy(&(sa4->sin_addr.s_addr), addr, 4);
01616         memcpy(&(sa4->sin_addr), addr, 4);
01617         sa = (struct sockaddr*)sa4;
01618     }
01619 
01620     return sa;
01621 }

struct sockaddr* make_sockaddr_bystr ( const char *  addr,
int  port 
) [read]

struct sockaddr* make_sockaddr_bystr(const char* addr, int port)

文字列の IPv4/IPv6 アドレスとポート番号から 有効な struct sockaddr を作り出す

Parameters:
addr 文字列のIPアドレス（IPv4/IPv6）
port ポート番号
Returns:
sa struct sockaddr へのポインタ．要 free

Definition at line 1634 of file network6.c.

References make_sockaddr_bynum().

01635 {
01636     int   err, family = -1;
01637     char* pp;
01638     unsigned char num[16];
01639     struct sockaddr* sa;
01640 
01641     pp = strstr((char*)addr, ".");
01642     if (pp!=NULL) {
01643         family = AF_INET;
01644     }
01645     else {
01646         pp = strstr((char*)addr, ":");
01647         if (pp!=NULL) {
01648             family = AF_INET6;
01649         }
01650     }
01651     if (family<0) return NULL;
01652 
01653     memset(num, 0, 16);
01654     err = inet_pton(family, addr, num);
01655     if (err!=1) return NULL;
01656 
01657     sa  = make_sockaddr_bynum(num, port, family);
01658     return sa;
01659 }

Here is the call graph for this function:

int recv_wait ( int  sock,
int  tm 
)

int recv_wait(int sock, int tm)

簡易 受信 wait. ソケットにデータが受信されるまで待つ．スレッド対応

Parameters:
sock 監視するソケット
tm タイムアウトの秒数
Return values:
TRUE バッファにデータがある．
FALSE タイムアウトした．

Definition at line 1468 of file network6.c.

01469 {
01470     int    nd;
01471     fd_set mask;
01472     struct timeval timeout;
01473     time_t otm, ntm;
01474 
01475     otm = time(NULL);
01476     do {
01477         timeout.tv_sec  = tm;
01478         timeout.tv_usec = 0;
01479         FD_ZERO(&mask);
01480         FD_SET(sock, &mask);
01481 
01482         //DEBUG_MESG("Waiting sock = %d for %ds.\n", sock, tm);
01483         nd  = select(sock+1, &mask, NULL, NULL, &timeout);
01484         ntm = time(NULL);
01485     } while ((nd<0 || !FD_ISSET(sock, &mask)) && (int)(ntm-otm)<=tm);
01486 
01487     return FD_ISSET(sock, &mask);     
01488 }

int recv_wait_twin ( int  sock1,
int  sock2,
int  tm 
)

int recv_wait_twin(int sock1, int sock2, int tm)

簡易 受信 wait. 二つのソケット sock1, sock2 にデータが受信されるまで待つ．スレッド対応

Parameters:
sock1 監視するソケット その1
sock2 監視するソケット その2
tm タイムアウトの秒数
Return values:
0 タイムアウトした．
1 sock1 のバッファにデータがある．
2 sock2 のバッファにデータがある．
3 sock1 と sock2 のバッファにデータがある．

Definition at line 1506 of file network6.c.

References Max.

01507 {
01508     int    ret = 0;
01509     int    nm, nd;
01510     fd_set mask;
01511     struct timeval timeout;
01512     time_t otm, ntm;
01513 
01514     nm  = Max(sock1, sock2);
01515     otm = time(NULL);
01516     do {
01517         timeout.tv_sec  = tm;
01518         timeout.tv_usec = 0;
01519         FD_ZERO(&mask);
01520         FD_SET(sock1, &mask);
01521         FD_SET(sock2, &mask);
01522         nd  = select(nm+1, &mask, NULL, NULL, &timeout);
01523         ntm = time(NULL);
01524     } while ((nd<0 || (!FD_ISSET(sock1, &mask) && !FD_ISSET(sock2, &mask))) && (int)(ntm-otm)<=tm);
01525 
01526     if (FD_ISSET(sock1, &mask)) ret += 1;
01527     if (FD_ISSET(sock2, &mask)) ret += 2;
01528 
01529     return ret;
01530 }

int send_wait ( int  sock,
int  tm 
)

int send_wait(int sock, int tm)

簡易 送信 wait. データが送信可能になるまで待つ．スレッド対応

Parameters:
sock 監視するソケット
tm タイムアウトの秒数
Return values:
TRUE バッファにデータがある．
FALSE タイムアウトした．

Definition at line 1545 of file network6.c.

01546 {
01547     int    nd;
01548     fd_set mask;
01549     struct timeval timeout;
01550     time_t otm, ntm;
01551 
01552     otm = time(NULL);
01553     do {
01554         timeout.tv_sec  = tm;
01555         timeout.tv_usec = 0;
01556         FD_ZERO(&mask);
01557         FD_SET(sock, &mask);
01558 
01559         //DEBUG_MESG("Waiting sock = %d for %ds.\n", sock, tm);
01560         nd  = select(sock+1, NULL, &mask, NULL, &timeout);
01561         ntm = time(NULL);
01562     } while ((nd<0 || !FD_ISSET(sock, &mask)) && (int)(ntm-otm)<=tm);
01563 
01564     return FD_ISSET(sock, &mask);     
01565 }

int set_block_socket ( int  sock  ) 

int set_block_socket(int sock)

Definition at line 1077 of file network6.c.

01078 {
01079 #ifdef WIN32
01080     u_long val = 0;
01081     ioctlsocket(sock, FIONBIO, &val);
01082 #else
01083     int val = fcntl(sock, F_GETFL, 0);
01084     if (val>=0) fcntl(sock, F_SETFL, val & ~O_NONBLOCK);
01085 #endif
01086     return sock;
01087 }

int set_nonblock_socket ( int  sock  ) 

int set_nonblock_socket(int sock)

Definition at line 1060 of file network6.c.

01061 {
01062 #ifdef WIN32
01063     u_long val = 1;
01064     ioctlsocket(sock, FIONBIO, &val);
01065 #else
01066     int val = fcntl(sock, F_GETFL, 0);
01067     if (val>=0) fcntl(sock, F_SETFL, val | O_NONBLOCK);
01068 #endif
01069     return sock;
01070 }

int socket_close ( int  sofd  ) 

int socket_close(int sofd)

未送信のデータを破棄して，ソケットを完全に閉じる．

Attention:
fork() した場合，親プロセスで socket_close()すると，子プロセスのソケットにも影響を及ぼす．
Parameters:
sofd クローズしたいソケット記述子を指定．
Return values:
1以上 最後に受信したバイト数
0 正常切断．
-1 エラー

Definition at line 1039 of file network6.c.

01040 {
01041     int  err = -1;
01042 
01043     if (sofd>0) {
01044         #ifdef WIN32
01045             err = shutdown(sofd, 2);
01046             closesocket(sofd);
01047         #else
01048             err = shutdown(sofd, SHUT_RDWR);
01049             close(sofd);
01050         #endif
01051     }
01052     return err;
01053 }

int tcp_recv ( int  sock,
char *  rmsg,
int  size 
)

int tcp_recv(int sock, char* rmsg, int size)

recv()をラッピングした関数．TCP経由でデータを受信する．

Parameters:
sock ソケット記述子
rmsg 受信用データバッファ．関数内で初期化される．
size データバッファのサイズ
Return values:
1以上 受信したバイト数．
0 正常切断．
JBXL_NET_RECV_ERROR 失敗

Definition at line 1245 of file network6.c.

References JBXL_NET_RECV_ERROR.

01246 {
01247     int cc;
01248 
01249     memset(rmsg, 0, size);
01250     cc = recv(sock, rmsg, size, 0);
01251 
01252     if (cc<0) cc = JBXL_NET_RECV_ERROR;
01253     return cc;
01254 }

int tcp_recv_mstream ( int  sock,
char *  mesg,
int  sz,
mstream *  sb,
int  tm 
)

int tcp_recv_mstream(int sock, char* mesg, int sz, mstream* sb, int tm)

TCP経由でメッセージ(文字列)を受信する．受信メッセージはメッセージストリームバッファに一旦バッファリングされ， この関数により一行ずつ読み出される．mesgには最大 sz-1文字が格納される． もし，バッファ中の一行のデータが sz-1より大きい場合は，はみ出した部分は捨てられる．

mesgに格納される時，行中の改行コードは削除され，行末には必ず '\0' が入る． タイムアウトの設定が可能でタイムアウトに 0を指定した場合, 呼び出した時点で 読み込み可能データがなければすぐにタイムアウトとなる (JBXL_NET_RECV_TIMEOUT が返る)．

メッセージストリームのバッファ部が確保されていない場合は，最初に呼び出された時点で確保される． 一旦この関数を使用して，受信データをバッファリングしたら，ソケットをクローズするまで， 読み取りには必ず同じストリームを使用してこの関数を呼び出さばければならない． そうで無い場合は受信データの整合性は保証されない．

Parameters:
sock ソケット記述子
mesg 受信用データバッファ．予め十分なメモリ領域を確保しておく．
sz データバッファのサイズ
sb リングバッファ型のストリームバッファ． バッファ部が確保されていなければ，自動的に確保される．
tm タイムアウト時間．秒単位．
Return values:
1以上 mesgに格納したメッセージのバイト数．
0 おそらくは相手側がセッションをクローズした．
JBXL_NET_RECV_ERROR 受信エラー．
JBXL_ARGS_ERROR 引数に NULLのデータがある．
JBXL_MALLOC_ERROR メッセージバッファ部が無いので確保しようとしたが，確保に失敗した．
JBXL_NET_BUF_ERROR メッセージバッファにデータは存在するはずだが，原因不明の理由により獲得に失敗した．
JBXL_NET_BUFSZ_ERROR メッセージバッファ中のデータの長さが，mesgの長さより大きい．はみ出した部分は捨てられた．
JBXL_NET_RECV_TIMEOUT タイムアウト．

Definition at line 1419 of file network6.c.

References get_mstream(), JBXL_ARGS_ERROR, JBXL_MALLOC_ERROR, JBXL_NET_BUF_ERROR, JBXL_NET_BUFSZ_ERROR, JBXL_NET_RECV_ERROR, make_mstream, put_mstream(), RECVBUFSZ, and tcp_recv_wait().

01420 {
01421     int  cc;
01422     unsigned char* pp;
01423 
01424     if (mesg==NULL || sb==NULL) return JBXL_ARGS_ERROR;
01425     //memset(mesg, 0, sz);
01426 
01427     if (sb->buf==NULL) {
01428         *sb = make_mstream(RECVBUFSZ);
01429         if (sb->buf==NULL) return JBXL_MALLOC_ERROR;
01430     }
01431 
01432     while (sb->datano==0) {
01433         cc = tcp_recv_wait(sock, mesg, sz, tm);
01434         if (cc<=0) {
01435             if (cc<0) cc = JBXL_NET_RECV_ERROR;
01436             return cc;
01437         }
01438         put_mstream(sb, (unsigned char*)mesg);
01439         //memset(mesg, 0, sz);
01440     }
01441 
01442     pp = get_mstream(sb);
01443     if (pp==NULL) return JBXL_NET_BUF_ERROR;
01444     if (strlen((const char*)pp)>=(unsigned int)sz) {
01445         memcpy(mesg, pp, sz-1);
01446         free(pp);
01447         return JBXL_NET_BUFSZ_ERROR;
01448     }
01449     memcpy(mesg, pp, strlen((const char*)pp));
01450 
01451     free(pp);
01452     return (int)strlen(mesg);
01453 }

Here is the call graph for this function:

int tcp_recv_wait ( int  sock,
char *  mesg,
int  sz,
int  tm 
)

int tcp_recv_wait(int sock, char* mesg, int sz, int tm)

TCP経由でデータを受信する．

タイムアウトの設定が可能．タイムアウトに 0を指定した場合, recv_wait() 関数を呼び出した時点で読み込み可能データがなければすぐにタイムアウトとなる (JBXL_NET_RECV_TIMEOUT が返る)．

Parameters:
sock ソケット記述子
mesg 受信用データバッファ．関数内で初期化される．
sz データバッファのサイズ
tm タイムアウト時間．秒単位．
Return values:
1以上 受信したバイト数．
0 おそらくは相手側がセッションをクローズした．
JBXL_NET_RECV_ERROR 受信エラー．
JBXL_NET_RECV_TIMEOUT タイムアウト．

Definition at line 1339 of file network6.c.

References JBXL_NET_RECV_ERROR, JBXL_NET_RECV_TIMEOUT, and recv_wait().

01340 {
01341     int  cc;
01342 
01343     memset(mesg, 0, sz);
01344     if (recv_wait(sock, tm)) {
01345         cc = recv(sock, mesg, sz, 0); 
01346     }
01347     else {
01348         return JBXL_NET_RECV_TIMEOUT;
01349     }
01350 
01351     if (cc<0) cc = JBXL_NET_RECV_ERROR;
01352     return cc;
01353 }

Here is the call graph for this function:

int tcp_send ( int  sock,
char *  smsg,
int  size 
)

int tcp_send(int sock, char* smsg, int size)

send()をラッピングした関数．TCP経由でデータを送る．

データ(smsg)のサイズ sizeに0以下を指定した場合は，smsgは文字列であると見なして,サイズを自動的に計算する．

Parameters:
sock ソケット記述子
smsg 送信するデータ
size 送信するデータ（smsg）のサイズ．サイズが 0以下の場合は smsgは文字列であるとみなす．
Return values:
0以上 送信したバイト数．
JBXL_NET_SEND_ERROR 失敗

Definition at line 1272 of file network6.c.

References JBXL_NET_SEND_ERROR.

01273 {
01274     int cc;
01275 
01276     if (size<=0) size = (int)strlen(smsg);
01277     cc = send(sock, smsg, size, 0);
01278 
01279     if (cc<0) cc = JBXL_NET_SEND_ERROR;
01280     return cc;
01281 }

int tcp_send_mesgln ( int  sock,
char *  mesg 
)

int tcp_send_mesgln(int sock, char* mesg)

TCPメッセージ(文字列)に改行(\r\n)を付け加えて送信する．

Parameters:
sock ソケット記述子
mesg 送信用メッセージ
Return values:
0以上 送信したバイト数．
JBXL_NET_SEND_ERROR 失敗．

Definition at line 1368 of file network6.c.

References JBXL_NET_SEND_ERROR.

01369 {
01370     int   cc, sz;
01371     char* buf;
01372 
01373     sz = (int)strlen(mesg) + 3;    /* CR+LF+0x00 */
01374     buf = (char*)malloc(sz);
01375     if (buf==NULL) return JBXL_NET_SEND_ERROR;
01376 
01377     strncpy(buf, mesg, sz);
01378     strncat(buf, "\r\n", 2);
01379     cc = send(sock, buf, (int)strlen(buf), 0);
01380 
01381     free(buf);
01382     if (cc<0) cc = JBXL_NET_SEND_ERROR;
01383     return cc;
01384 }

char* to_address_char ( unsigned char *  addr,
int  mask,
int  family 
)

char* to_address_char(unsigned char* addr, int mask, int family)

数字型の IPv4/IPv6 アドレス（サブネット付き）8/32Byteを文字型の [IPアドレス]/[ネットマスク] に変換する．

addr は必ずネットマスクの情報を含み，長さが 8/32Byteでないといけない．
to_address_num()と対で使うのが安全．

Parameters:
addr 変換するバイバリ型のIPアドレス
mask 0: サブネットマスクの処理をしない．
mask 0以外: サブネットマスクの処理を行う．
family アドレスファミリー (AF_INET/AF_INET6)
Returns:
[IPv4/IPv6 アドレス]/[ネットマスク] 形式の文字列．要 free
See also:
to_address_num()

Definition at line 2538 of file network6.c.

References LEN_IPADDR, and LEN_IPADDR6.

02539 {
02540     int mlen, plen, slen;
02541     char* str;
02542     if (addr==NULL) return NULL;
02543 
02544     plen = 16;
02545     mlen = LEN_IPADDR6*2;
02546     if (family!=AF_INET6) {
02547         family = AF_INET;
02548         plen = 4;
02549         mlen = LEN_IPADDR*2;
02550     }
02551 
02552     str = (char*)malloc(mlen);
02553     if (str==NULL) return NULL;
02554     memset(str, 0, mlen);
02555 
02556     inet_ntop(family, addr, str, mlen);
02557     if (mask==0) return str;
02558 
02559     slen = (int)strlen(str);
02560     str[slen++] = '/';
02561     inet_ntop(family, addr+plen, str+slen, mlen-slen);
02562 
02563     return str;
02564 }

unsigned char* to_address_num ( char *  addr,
int  mode,
int  mask,
int  family 
)

unsigned char* to_address_num(char* addr, int mode, int mask, int family)

文字型のアドレス [IPアドレス]/[ネットマスク] (例：202.26.159.140/255.255.255.0）を 数字型のアドレス（unsigned char* num）8/32Byte へ変換する．

省略された場所は 0とみなされる（例：202.26/255 → 202.26.0.0/255.0.0.0）
ネットマスク部全体が省略された場合は IPアドレス部に依存する．(202.26. → 202.26.0.0/255.255.0.0)
CIDER形式にも対応．ただし，ネットマスク部の妥当性はチェックしない．

Parameters:
addr 変換する文字型のIPアドレス または FQDN
mode 0: IPアドレス以外のもの（英字）は NULL を返す．
mode 0以外: FQDNはIPアドレスに変換して返す（時間がかかる）
mask 0: サブネットマスクの処理をしない．
mask 0以外: サブネットマスクの処理を行う．
family アドレスファミリー (AF_INET/AF_INET6)
Returns:
[IPv4/IPv6 アドレス],[ネットマスク] の長さ8/32Byteのバイナリ．要 free

Definition at line 2414 of file network6.c.

References awk(), get_ipaddr_byname_num(), Max, Min, OFF, and ON.

02415 {
02416     unsigned char* num;
02417     char  deli;
02418     char* ps;
02419     char* pc;
02420     char* uc = NULL;
02421     int   i, len;
02422 
02423     if (addr==NULL) return NULL;
02424 
02425     deli = ':';
02426     len  = 16;
02427     if (family!=AF_INET6) {
02428         deli = ':';
02429         len  = 4;
02430         family = AF_INET;
02431     }
02432 
02433     // mode チェック
02434     if (mode==0) {
02435         i = (int)strlen(addr) - 1;
02436         while (i>0 && addr[i]==deli) i--;
02437         if (i>=0) {
02438             if (isalpha(addr[i])) return NULL;
02439         }   
02440     }
02441 
02442     num = (unsigned char*)malloc(len*2);
02443     if (num==NULL) return NULL;
02444     memset(num, 0, len*2);
02445 
02446     // IPアドレス部の変換
02447     ps = awk(addr, '/', 1);
02448     if (ps==NULL) {
02449         free(num);
02450         return NULL;
02451     }
02452 
02453     uc = (char*)get_ipaddr_byname_num(ps, family); 
02454     free(ps);
02455     if (uc==NULL) return NULL;
02456     memcpy(num, uc, len);
02457     free(uc);
02458 
02459     if (mask==0) return num;
02460 
02461     // 以下，サブネットマスク処理
02462     ps = awk(addr, '/', 2);
02463 
02464     // サブネットマスク部が省略された場合の処理 
02465     if (ps==NULL) {
02466         int f = OFF;
02467         for (i=len-1; i>=0; i--) {
02468             if (num[i]!=0 || f==ON) {
02469                 num[i+len] = 0xff;
02470                 f = ON;
02471             }
02472             else {
02473                 num[i+len] = 0;
02474             }
02475         }
02476         return num;
02477     }
02478 
02479     // サブネットマスク部の処理
02480     if (family==AF_INET) {
02481         for (i=0; i<len; i++) {
02482             pc = awk(ps, deli, i+1);
02483             if (pc==NULL) break;
02484             num[i+len] = (unsigned char)atoi(pc);
02485             free(pc);
02486         }
02487     }
02488     else {
02489         for (i=0; i<len/2; i++) {
02490             pc = awk(ps, deli, i+1);
02491             if (pc==NULL) break;
02492             int nn = strtol(pc, NULL, 16);
02493             num[len+i*2]   = (unsigned char)(nn/256);
02494             num[len+i*2+1] = (unsigned char)(nn%256);
02495             free(pc);
02496         }
02497     }
02498     free(ps);
02499 
02500     // CIDER形式対応
02501     if (family==AF_INET && num[4]<=32) {
02502         int nn, cl = (int)num[4];
02503         for (i=0; i<4; i++) {
02504             nn = 8 - Max(0, Min(8, cl-8*i));
02505             num[i+4] = 0xff<<nn;
02506         }
02507     }
02508     else if (family==AF_INET6 && num[16]<16) {
02509         int nn, cl = num[16]%16*100 + num[17]/16*10 + num[17]%16;
02510         for (i=0; i<16; i++) {
02511             nn = 8 - Max(0, Min(8, cl-8*i));
02512             num[i+16] = 0xff<<nn;
02513         }
02514     }
02515 
02516     return num;
02517 }

Here is the call graph for this function:

int udp_client_socket_sockaddr_in ( char *  hostname,
int  port,
struct sockaddr_in *  sv_addr 
)

Definition at line 2597 of file network6.c.

References JBXL_NET_INFO_ERROR, JBXL_NET_SOCKET_ERROR, and socket_close().

02598 {
02599     int  sofd;
02600     struct hostent* shost = NULL; 
02601  
02602     if (sv_addr==NULL) return JBXL_NET_INFO_ERROR;
02603 
02604     sofd = (int)socket(AF_INET, SOCK_DGRAM, 0);
02605     if (sofd<0) return JBXL_NET_SOCKET_ERROR;
02606 
02607     shost = gethostbyname(hostname); 
02608     if (shost==NULL) {
02609         socket_close(sofd);
02610         return JBXL_NET_INFO_ERROR;
02611     }
02612 
02613     memset(sv_addr, 0, sizeof(*sv_addr));
02614     sv_addr->sin_family = AF_INET;
02615     sv_addr->sin_port   = htons(port);
02616     memcpy(&(sv_addr->sin_addr), shost->h_addr, shost->h_length);
02617    
02618     return sofd;
02619 }

Here is the call graph for this function:

void udp_hole_punching ( int  sock,
struct addrinfo *  addr,
int  nm 
)

void udp_hole_punching(int sock, struct sockaddr_in addr, int nm)

sock を使って，addrへ nmバイトの NULLデータを送信する．

Parameters:
sock ソケット記述子
addr 相手のホストの情報が格納されて sockaddr_in 構造体
nm 送信するデータ(NULL)の長さ

Definition at line 2577 of file network6.c.

References LBUF, and udp_send().

02578 {
02579     char data[LBUF];
02580 
02581     if (nm<=0) nm = 4;                // for SLVoice
02582     else if (nm>LBUF) nm = LBUF;
02583 
02584     memset(data, 0, nm);
02585     udp_send(sock, data, nm, addr);
02586 
02587     return;
02588 }

Here is the call graph for this function:

void udp_hole_punching_sockaddr_in ( int  sock,
struct sockaddr_in  addr,
int  nm 
)

void udp_hole_punching_sockaddr_in(int sock, struct sockaddr_in addr, int nm)

sock を使って，addrへ nmバイトの NULLデータを送信する．

Parameters:
sock ソケット記述子
addr 相手のホストの情報が格納されて sockaddr_in 構造体
nm 送信するデータ(NULL)の長さ

Definition at line 2793 of file network6.c.

References LBUF, and udp_send_sockaddr_in().

02794 {
02795     char data[LBUF];
02796 
02797     if (nm<=0) nm = 4;                // for SLVoice
02798     else if (nm>LBUF) nm = LBUF;
02799 
02800     memset(data, 0, nm);
02801     udp_send_sockaddr_in(sock, data, nm, &addr);
02802 
02803     return;
02804 }

Here is the call graph for this function:

int udp_recv ( int  sock,
char *  rmsg,
int  size,
struct addrinfo *  sv_addr 
)

int udp_recv(int sock, char* rmsg, int size, struct addrinfo* sv_addr)

recvform() をラッピングした関数．UDPデータを受信する．

Parameters:
sock ソケット記述子
rmsg 受信用データバッファ．関数内で初期化される．
size データバッファのサイズ
sv_addr サーバの情報が格納された addrinfo 構造体へのポインタ．
Return values:
1以上 受信したバイト数．
0 正常切断．
JBXL_NET_RECV_ERROR 失敗
JBXL_ARGS_ERROR 不正な引数

Definition at line 1183 of file network6.c.

References JBXL_ARGS_ERROR, and JBXL_NET_RECV_ERROR.

01184 {
01185     int cc;
01186     socklen_t cadlen;
01187 
01188     if (sv_addr==NULL) return JBXL_ARGS_ERROR;
01189 
01190     cadlen = (int)sv_addr->ai_addrlen;
01191     memset(rmsg, 0, size);
01192     cc = recvfrom(sock, rmsg, size, 0, sv_addr->ai_addr, &cadlen);
01193 
01194     if (cc<0) cc = JBXL_NET_RECV_ERROR;
01195     return cc;
01196 }

int udp_recv_sockaddr_in ( int  sock,
char *  rmsg,
int  size,
struct sockaddr_in *  sv_addr 
)

Definition at line 2622 of file network6.c.

02623 {
02624     int cc;
02625     socklen_t cadlen;
02626 
02627     if (sv_addr==NULL) return 0;
02628 
02629     cadlen = sizeof(*sv_addr);
02630     memset(rmsg, 0, size);
02631     cc = recvfrom(sock, rmsg, size, 0, (struct sockaddr*)sv_addr, &cadlen);
02632 
02633     return cc;
02634 }

int udp_recv_wait ( int  sock,
char *  rmsg,
int  size,
struct addrinfo *  sv_addr,
int  tm 
)

int udp_recv_wait(int sock, char* rmsg, int size, struct addrinfo* sv_addr, int tm)

UDP経由でデータを受信する．

タイムアウトの設定が可能．タイムアウトに 0を指定した場合, recv_wait() 関数を呼び出した時点で読み込み可能データがなければすぐにタイムアウトとなる (JBXL_NET_RECV_TIMEOUT が返る)．

Parameters:
sock ソケット記述子
rmsg 受信用データバッファ．関数内で初期化される．
size データバッファのサイズ
sv_addr サーバの情報が格納された addrinfo 構造体へのポインタ．
tm タイムアウト時間．秒単位．
Return values:
1以上 受信したバイト数．
0 正常切断．
JBXL_NET_RECV_ERROR 失敗．
JBXL_NET_RECV_TIMEOUT タイムアウト．

Definition at line 1304 of file network6.c.

References JBXL_NET_RECV_ERROR, JBXL_NET_RECV_TIMEOUT, recv_wait(), and udp_recv().

01305 {
01306     int  cc;
01307 
01308     if (recv_wait(sock, tm)) {
01309         cc = udp_recv(sock, rmsg, size, sv_addr); 
01310     }
01311     else {
01312         return JBXL_NET_RECV_TIMEOUT;
01313     }
01314 
01315     if (cc<0) cc = JBXL_NET_RECV_ERROR;
01316     return cc;
01317 }

Here is the call graph for this function:

int udp_recv_wait_sockaddr_in ( int  sock,
char *  rmsg,
int  size,
struct sockaddr_in *  sv_addr,
int  tm 
)

Definition at line 2651 of file network6.c.

References JBXL_NET_RECV_TIMEOUT, recv_wait(), and udp_recv_sockaddr_in().

02652 {
02653     int  cc;
02654 
02655     if (recv_wait(sock, tm)) {
02656         cc = udp_recv_sockaddr_in(sock, rmsg, size, sv_addr); 
02657     }
02658     else {
02659         return JBXL_NET_RECV_TIMEOUT;
02660     }
02661     return cc;
02662 }

Here is the call graph for this function:

int udp_send ( int  sock,
char *  smsg,
int  size,
struct addrinfo *  sv_addr 
)

int udp_send(int sock, char* smsg, int size, struct addrinfo* sv_addr)

sendto() をラッピングした関数．UDP経由でデータを送る．

データ(smsg)のサイズ sizeに0以下を指定した場合は，smsgは文字列で あると見なしてサイズを自動的に計算する．

Parameters:
sock ソケット記述子
smsg 送信するデータ
size 送信するデータ（smsg）のサイズ．サイズが 0以下の場合は smsgは文字列であるとみなす．
sv_addr サーバの情報を格納する addrinfo 構造体へのポインタ．
Return values:
0以上 送信したバイト数．
JBXL_NET_SEND_ERROR 失敗
JBXL_ARGS_ERROR 不正な引数

Definition at line 1217 of file network6.c.

References JBXL_ARGS_ERROR, and JBXL_NET_SEND_ERROR.

01218 {
01219     int cc;
01220 
01221     if (sv_addr==NULL) return JBXL_ARGS_ERROR;
01222 
01223     if (size<=0) size = (int)strlen(smsg);
01224     cc = sendto(sock, smsg, size, 0, sv_addr->ai_addr, (int)sv_addr->ai_addrlen);
01225 
01226     if (cc<0) cc = JBXL_NET_SEND_ERROR;
01227     return cc;
01228 }

int udp_send_sockaddr_in ( int  sock,
char *  smsg,
int  size,
struct sockaddr_in *  sv_addr 
)

Definition at line 2638 of file network6.c.

02639 {
02640     int cc;
02641 
02642     if (sv_addr==NULL) return 0;
02643     if (size<=0) size = (int)strlen(smsg);
02644     cc = sendto(sock, smsg, size, 0, (struct sockaddr*)sv_addr, sizeof(*sv_addr));
02645 
02646     return cc;
02647 }

Generated on 15 Nov 2023 for JunkBox_Lib by  doxygen 1.6.1