JunkBox_Lib: Lib/network6.c Source File

00001 //
00009 #ifdef CPLUSPLUS
00010     #undef CPLUSPLUS
00011 #endif
00012 
00013 
00014 #include "network.h"
00015 #include <time.h>
00016 
00017 
00019 // for WinSock
00020 //
00021 
00022 #ifdef WIN32
00023 WSADATA WsaData;
00024 #endif
00025 
00026 
00027 int  init_network(void)
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 }
00039 
00040 
00041 void  cleanup_network(void)
00042 {
00043 #ifdef WIN32
00044     WSACleanup();
00045 #endif
00046 }
00047 
00048 
00049 
00050 
00052 // Berkeley Socket
00053 //
00054 
00072 int  _udp_server_socket(int port, struct addrinfo** sv_addr, int family) 
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 }
00135 
00136 
00137 
00159 int  _udp_server_socket_setopt(int port, int opt, const void* optval, int optlen, struct addrinfo** sv_addr, int family) 
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 }
00220 
00221 
00222 
00241 int  _udp_client_socket(char* hostname, int port, struct addrinfo** sv_addr, int family)
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 }
00271 
00272 
00273 
00288 int  _udp_bind(int sofd, int port, int family) 
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 }
00317 
00318 
00319 
00338 int  _udp_bind_setopt(int sofd, int port, int opt, const void* optval, int optlen, int family) 
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 }
00382 
00383 
00384 
00403 int  _tcp_server_socket(int port, int family) 
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 }
00464 
00465 
00466 
00490 int  _tcp_server_socket_setopt(int port, int opt, const void* optval, int optlen, int family) 
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 }
00551 
00552 
00553 
00571 int  _tcp_server_bind(int port, int family) 
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 }
00625 
00626 
00627 
00649 int  _tcp_server_bind_setopt(int port, int opt, const void* optval, int optlen, int family) 
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 }
00703 
00704 
00705 
00723 int  _tcp_client_socket(char* hostname, int port, int family) 
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 }
00757 
00758 
00759 
00779 int  _tcp_client_bind_socket(char* hostname, int sport, int cport, int family)  
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 }
00830 
00831 
00832 
00847 int  _tcp_bind(int sofd, int port, int family)  
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 }
00879 
00880 
00881 
00900 int  _tcp_bind_setopt(int sofd, int port, int opt, const void* optval, int optlen, int family)
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 }
00944 
00945 
00946 
00947 /*
00948 int  _tcp_connect(int sofd, char* hostname, int port, int family) 
00949 
00950 IPv4/IPv6 のTCPのクライアントソケットを通して，サーバに接続する．
00951 
00952 この関数内で呼び出される関数: getaddrinfo(), connect()
00953 
00954 @param  sofd     ソケット記述子
00955 @param  hostname サーバ名
00956 @param  port     サーバポート番号
00957 @param  family   プロトコルファミリー（AF_INET/AF_INET6/AF_UNSPEC)． 
00958                  AF_UNSPEC の場合は先ずIPv6で接続を試み，不可ならIPv4で接続する．
00959 
00960 @retval 0以上  作成されたソケット記述子．
00961 @retval JBXL_NET_INFO_ERROR      ホスト情報の取得に失敗．
00962 @retval JBXL_NET_CONNECT_ERROR   接続に失敗．
00963  */
00964 int  _tcp_connect(int sofd, char* hostname, int port, int family) 
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 }
00995 
00996 
00997 
01011 int accept_intr(int sock, struct sockaddr* cl_addr, socklen_t* cdlen)
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 }
01023 
01024 
01025 
01039 int  socket_close(int sofd)
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 }
01054 
01055 
01060 int   set_nonblock_socket(int sock)
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 }
01071 
01072 
01077 int   set_block_socket(int sock)
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 }
01088 
01089 
01091 // Valid Sockets
01092 //
01093 
01094 int  get_valid_udp_socket(int min, int max, unsigned short* port)
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 }
01116 
01117 
01118 int  get_valid_tcp_server_socket(int min, int max, unsigned short* port)
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 }
01138 
01139 
01140 int  get_valid_tcp_client_socket(int min, int max, char* hname, unsigned short sport, unsigned short* cport)
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 }
01160 
01161 
01162 
01163 
01165 // Communication
01166 // 
01167 
01183 int  udp_recv(int sock, char* rmsg, int size, struct addrinfo* sv_addr)
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 }
01197 
01198 
01199 
01217 int  udp_send(int sock, char* smsg, int size, struct addrinfo* sv_addr)
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 }
01229 
01230 
01231 
01245 int  tcp_recv(int sock, char* rmsg, int size)
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 }
01255 
01256 
01257 
01272 int  tcp_send(int sock, char* smsg, int size)
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 }
01282 
01283 
01284 
01304 int  udp_recv_wait(int sock, char* rmsg, int size, struct addrinfo* sv_addr, int tm)
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 }
01318 
01319 
01320 
01339 int  tcp_recv_wait(int sock, char* mesg, int sz, int tm)
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 }
01354 
01355 
01356 
01368 int  tcp_send_mesgln(int sock, char* mesg)
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 }
01385 
01386 
01387 
01419 int  tcp_recv_mstream(int sock, char* mesg, int sz, mstream* sb, int tm)
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 }
01454 
01455 
01456 
01468 int   recv_wait(int sock, int tm)
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 }
01489 
01490 
01491 
01506 int   recv_wait_twin(int sock1, int sock2, int tm)
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 }
01531 
01532 
01533 
01545 int   send_wait(int sock, int tm)
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 }
01566 
01567 
01568 
01569 
01571 // IP address
01572 //
01573 
01584 struct sockaddr*  make_sockaddr_bynum(unsigned char* addr, int port, int family)
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 }
01622 
01623 
01624 
01634 struct sockaddr*  make_sockaddr_bystr(const char* addr, int port)
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 }
01660 
01661 
01662 
01672 char*  get_hostname_bynum(unsigned char* num, int family) 
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 }
01704 
01705 
01706 
01715 char*  get_hostname_bystr(const char* addr) 
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 }
01746 
01747 
01748 
01761 char*  _get_hostname(const char* addr, int family)
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 }
01802 
01803 
01804 
01814 char*  get_ipaddr_byname(const char* hostname, int family)
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 }
01835 
01836 
01837 
01847 unsigned char*  get_ipaddr_byname_num(const char* hostname, int family)
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 }
01885 
01886 
01887 
01888 #ifdef WIN32
01889 
01890 #include <iphlpapi.h>
01891 #pragma comment( lib, "iphlpapi.lib" )
01892 
01893 char* get_myipaddr(int family)
01894 {
01895     int   len, prefix, fndflg;
01896     char* ipa;
01897     char  address[LNAME];
01898     IP_ADAPTER_ADDRESSES* pp, * pl;
01899     IP_ADAPTER_UNICAST_ADDRESS* pu;
01900 
01901     len = LEN_IPADDR6;
01902     if (family != AF_INET6) {
01903         len = LEN_IPADDR;
01904         family = AF_INET;
01905     }
01906 
01907     ULONG flags = GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER;
01908     DWORD err, size = 0;
01909 
01910     err = GetAdaptersAddresses(family, flags, NULL, NULL, &size);
01911     if (err != ERROR_BUFFER_OVERFLOW) return NULL;
01912 
01913     pp = (IP_ADAPTER_ADDRESSES*)malloc(size);
01914     if (pp == NULL) return NULL;
01915     err = GetAdaptersAddresses(family, flags, NULL, pp, &size);
01916     if (err != ERROR_SUCCESS) {
01917         free(pp);
01918         return NULL;
01919     }
01920 
01921     prefix = 0;
01922     fndflg = OFF;
01923     pl = pp;
01924     while (pl != NULL) {
01925         pu = pl->FirstUnicastAddress;
01926         while (pu != NULL) {
01927             if ((long)pu->ValidLifetime >= 0) {
01928                 prefix = pu->OnLinkPrefixLength;
01929                 struct sockaddr* sa = pu->Address.lpSockaddr;
01930                 if (family == AF_INET6) {
01931                     unsigned char* ch = (unsigned char*)&((struct sockaddr_in6*)sa)->sin6_addr;
01932                     if (!(ch[0] == 0xfe && ch[1] == 0x80)) {
01933                         fndflg = ON;
01934                         inet_ntop(AF_INET6, ch, address, LNAME);
01935                         break;
01936                     }
01937                 }
01938                 else {
01939                     unsigned char* ch = (unsigned char*)&((struct sockaddr_in*)sa)->sin_addr;
01940                     if (!(ch[0] == 169 && ch[1] == 254)) {
01941                         fndflg = ON;
01942                         inet_ntop(AF_INET, ch, address, LNAME);
01943                         break;
01944                     }
01945                 }
01946             }
01947             pu = pu->Next;
01948         }
01949         if (fndflg == ON) break;
01950         pl = pl->Next;
01951     }
01952     free(pp);
01953 
01954     int addrlen = (int)strlen(address);
01955     snprintf(address + addrlen, LNAME - addrlen - 1, "/%d\0", prefix);
01956 
01957     ipa = (char*)malloc(len);
01958     if (ipa == NULL) return NULL;
01959     memset(ipa, 0, len);
01960     memcpy(ipa, address, strlen(address)+1);
01961 
01962     return ipa;
01963 }
01964 
01965 #else
01966 
01967 #include <ifaddrs.h>
01968 
01969 char*  get_myipaddr(int family) 
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 }
02038 
02039 
02040 #endif
02041 
02042 
02043 unsigned char*  get_myipaddr_num(int family) 
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 }
02086 
02087 
02088 
02099 char*  _get_localip_bydest(const char* dest, int family)
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 }
02165 
02166 
02167 
02177 char*  get_mynetaddr(int family)
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 }
02203 
02204 
02205 
02213 unsigned char*  get_mynetaddr_num(int family)
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 }
02238 
02239 
02240 
02241 
02243 // Tools
02244 //
02245 
02257 int  is_same_sockaddr(struct sockaddr* addr1, struct sockaddr* addr2) 
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 }
02306 
02307 
02308 
02322 int  is_same_network(char* addr1, char* addr2, char* mask)
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 }
02355 
02356 
02357 
02371 int  is_same_network_num(unsigned char* addr1, unsigned char* addr2, unsigned char* mask, int family)
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 }
02392 
02393 
02394 
02414 unsigned char*  to_address_num(char* addr, int mode, int mask, int family)
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 }
02518 
02519 
02520 
02538 char*  to_address_char(unsigned char* addr, int mask, int family)
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 }
02565 
02566 
02567 
02577 void  udp_hole_punching(int sock, struct addrinfo* addr, int nm)
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 }
02589 
02590 
02591 
02592 
02594 // for IPv4 only
02595 //
02596 
02597 int  udp_client_socket_sockaddr_in(char* hostname, int port, struct sockaddr_in* sv_addr)
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 }
02620 
02621 
02622 int  udp_recv_sockaddr_in(int sock, char* rmsg, int size, struct sockaddr_in* sv_addr)
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 }
02635 
02636 
02637 
02638 int  udp_send_sockaddr_in(int sock, char* smsg, int size, struct sockaddr_in* sv_addr)
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 }
02648 
02649 
02650 
02651 int  udp_recv_wait_sockaddr_in(int sock, char* rmsg, int size, struct sockaddr_in* sv_addr, int tm)
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 }
02663 
02664 
02665 
02666 struct sockaddr_in  get_sockaddr_in(char* hostname, unsigned short cport)
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 }
02686 
02687 
02688 
02689 struct sockaddr_in  get_sockaddr_in_bynum(char* ipnum, unsigned short cport)
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 }
02700 
02701 
02702 
02703 struct sockaddr_in  get_local_sockaddr_in(unsigned short cport)
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 }
02718 
02719 
02720 
02735 char*  get_ipaddr_ipv4(struct in_addr sin_addr)
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 }
02751 
02752 
02753 
02768 unsigned char*  get_ipaddr_num_ipv4(struct in_addr sin_addr)
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 }
02781 
02782 
02783 
02793 void  udp_hole_punching_sockaddr_in(int sock, struct sockaddr_in addr, int nm)
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 }
02805 
02806 
02807