libnatpmp-20230423/Changelog.txt010064400017500000024000000042121442121113700155460ustar00nanardstaff$Id: Changelog.txt,v 1.34 2023/04/23 10:46:11 nanard Exp $ 2013/11/26: enforce strict aliasing rules. 2013/09/10: small patch for MSVC >= 16 rename win32 implementation of gettimeofday() to natpmp_gettimeofday() 2012/08/21: Little change in Makefile removed warnings in testgetgateway.c Fixed bugs in command line argumentparsing in natpmpc.c 2011/08/07: Patch to build on debian/kFreeBSD. 2011/07/15: Put 3 clauses BSD licence at the top of source files. 2011/06/18: --no-undefined => -Wl,--no-undefined adding a natpmpc.1 man page 2011/05/19: Small fix in libnatpmpmodule.c thanks to Manuel Mausz 2011/01/03: Added an argument to initnatpmp() in order to force the gateway to be used 2011/01/01: fix in make install 2010/05/21: make install now working under MacOSX (and BSD) 2010/04/12: cplusplus stuff in natpmp.h 2010/02/02: Fixed compilation under Mac OS X 2009/12/19: improve and fix building under Windows. Project files for MS Visual Studio 2008 More simple (and working) code for Win32. More checks in the /proc/net/route parsing. Add some comments. 2009/08/04: improving getgateway.c for windows 2009/07/13: Adding Haiku code in getgateway.c 2009/06/04: Adding Python module thanks to David Wu 2009/03/10: Trying to have windows get gateway working if not using DHCP 2009/02/27: don't include declspec.h if not under WIN32. 2009/01/23: Prefixed the libraries name with lib 2008/10/06: Fixed a memory leak in getdefaultgateway() (USE_SYSCTL_NET_ROUTE) 2008/07/03: Adding WIN32 code from Robbie Hanson 2008/06/30: added a Solaris implementation for getgateway(). added a LICENCE file to the distribution 2008/05/29: Anonymous unions are forbidden in ANSI C. That was causing problems with non-GCC compilers. 2008/04/28: introduced strnatpmperr() improved natpmpc.c sample make install now install the binary 2007/12/13: Fixed getgateway.c for working under OS X ;) Fixed values for NATPMP_PROTOCOL_TCP and NATPMP_PROTOCOL_UDP 2007/12/11: Fixed getgateway.c for compilation under Mac OS X 2007/12/01: added some comments in .h 2007/11/30: implemented almost everything libnatpmp-20230423/Makefile010064400017500000024000000117231225142661400145720ustar00nanardstaff# $Id: Makefile,v 1.23 2013/11/26 16:38:15 nanard Exp $ # This Makefile is designed for use with GNU make # libnatpmp # (c) 2007-2013 Thomas Bernard # http://miniupnp.free.fr/libnatpmp.html OS = $(shell uname -s) CC = gcc INSTALL = install -p ARCH = $(shell uname -m | sed -e s/i.86/i686/) VERSION = $(shell cat VERSION) ifeq ($(OS), Darwin) JARSUFFIX=mac endif ifeq ($(OS), Linux) JARSUFFIX=linux endif ifneq (,$(findstring WIN,$(OS))) JARSUFFIX=win32 endif # APIVERSION is used in soname APIVERSION = 1 #LDFLAGS = -Wl,--no-undefined CFLAGS ?= -Os #CFLAGS = -g -O0 CFLAGS += -fPIC CFLAGS += -Wall #CFLAGS += -Wextra CFLAGS += -DENABLE_STRNATPMPERR #CFLAGS += -Wstrict-aliasing LIBOBJS = natpmp.o getgateway.o OBJS = $(LIBOBJS) testgetgateway.o natpmpc.o natpmp-jni.o STATICLIB = libnatpmp.a ifeq ($(OS), Darwin) SHAREDLIB = libnatpmp.dylib JNISHAREDLIB = libjninatpmp.dylib SONAME = $(basename $(SHAREDLIB)).$(APIVERSION).dylib CFLAGS := -DMACOSX -D_DARWIN_C_SOURCE $(CFLAGS) SONAMEFLAGS=-Wl,-install_name,$(JNISHAREDLIB) -dynamiclib -framework JavaVM else ifneq (,$(findstring WIN,$(OS))) SHAREDLIB = natpmp.dll JNISHAREDLIB = jninatpmp.dll CC = i686-w64-mingw32-gcc EXTRA_LD = -lws2_32 -lIphlpapi -Wl,--no-undefined -Wl,--enable-runtime-pseudo-reloc --Wl,kill-at else SHAREDLIB = libnatpmp.so JNISHAREDLIB = libjninatpmp.so SONAME = $(SHAREDLIB).$(APIVERSION) SONAMEFLAGS=-Wl,-soname,$(JNISHAREDLIB) endif endif HEADERS = natpmp.h EXECUTABLES = testgetgateway natpmpc-shared natpmpc-static INSTALLPREFIX ?= $(PREFIX)/usr INSTALLDIRINC = $(INSTALLPREFIX)/include INSTALLDIRLIB = $(INSTALLPREFIX)/lib INSTALLDIRBIN = $(INSTALLPREFIX)/bin JAVA ?= java JAVAC ?= javac JAVAH ?= javah JAVAPACKAGE = fr/free/miniupnp/libnatpmp JAVACLASSES = $(JAVAPACKAGE)/NatPmp.class $(JAVAPACKAGE)/NatPmpResponse.class $(JAVAPACKAGE)/LibraryExtractor.class $(JAVAPACKAGE)/URLUtils.class JNIHEADERS = fr_free_miniupnp_libnatpmp_NatPmp.h .PHONY: all clean depend install cleaninstall installpythonmodule all: $(STATICLIB) $(SHAREDLIB) $(EXECUTABLES) pythonmodule: $(STATICLIB) libnatpmpmodule.c setup.py python setup.py build touch $@ installpythonmodule: pythonmodule python setup.py install clean: $(RM) $(OBJS) $(EXECUTABLES) $(STATICLIB) $(SHAREDLIB) $(JAVACLASSES) $(JNISHAREDLIB) $(RM) pythonmodule $(RM) -r build/ dist/ libraries/ depend: makedepend -f$(MAKEFILE_LIST) -Y $(OBJS:.o=.c) 2>/dev/null install: $(HEADERS) $(STATICLIB) $(SHAREDLIB) natpmpc-shared $(INSTALL) -d $(INSTALLDIRINC) $(INSTALL) -m 644 $(HEADERS) $(INSTALLDIRINC) $(INSTALL) -d $(INSTALLDIRLIB) $(INSTALL) -m 644 $(STATICLIB) $(INSTALLDIRLIB) $(INSTALL) -m 644 $(SHAREDLIB) $(INSTALLDIRLIB)/$(SONAME) $(INSTALL) -d $(INSTALLDIRBIN) $(INSTALL) -m 755 natpmpc-shared $(INSTALLDIRBIN)/natpmpc ln -s -f $(SONAME) $(INSTALLDIRLIB)/$(SHAREDLIB) $(JNIHEADERS): fr/free/miniupnp/libnatpmp/NatPmp.class $(JAVAH) -jni fr.free.miniupnp.libnatpmp.NatPmp %.class: %.java $(JAVAC) -cp . $< $(JNISHAREDLIB): $(SHAREDLIB) $(JNIHEADERS) $(JAVACLASSES) ifeq (,$(JAVA_HOME)) @echo "Check your JAVA_HOME environement variable" && false endif ifneq (,$(findstring WIN,$(OS))) $(CC) -m32 -D_JNI_Implementation_ -Wl,--kill-at \ -I"$(JAVA_HOME)/include" -I"$(JAVA_HOME)/include/win32" \ natpmp-jni.c -shared \ -o $(JNISHAREDLIB) -L. -lnatpmp -lws2_32 -lIphlpapi else $(CC) $(CFLAGS) -c -I"$(JAVA_HOME)/include" -I"$(JAVA_HOME)/include/win32" natpmp-jni.c $(CC) $(CFLAGS) -o $(JNISHAREDLIB) -shared $(SONAMEFLAGS) natpmp-jni.o -lc -L. -lnatpmp endif jar: $(JNISHAREDLIB) find fr -name '*.class' -print > classes.list $(eval JNISHAREDLIBPATH := $(shell java fr.free.miniupnp.libnatpmp.LibraryExtractor)) mkdir -p libraries/$(JNISHAREDLIBPATH) mv $(JNISHAREDLIB) libraries/$(JNISHAREDLIBPATH)/$(JNISHAREDLIB) jar cf natpmp_$(JARSUFFIX).jar @classes.list libraries/$(JNISHAREDLIBPATH)/$(JNISHAREDLIB) $(RM) classes.list jnitest: $(JNISHAREDLIB) JavaTest.class $(RM) libjninatpmp.so $(JAVA) -Djna.nosys=true -cp . JavaTest mvn_install: mvn install:install-file -Dfile=java/natpmp_$(JARSUFFIX).jar \ -DgroupId=com.github \ -DartifactId=natpmp \ -Dversion=$(VERSION) \ -Dpackaging=jar \ -Dclassifier=$(JARSUFFIX) \ -DgeneratePom=true \ -DcreateChecksum=true cleaninstall: $(RM) $(addprefix $(INSTALLDIRINC), $(HEADERS)) $(RM) $(INSTALLDIRLIB)/$(SONAME) $(RM) $(INSTALLDIRLIB)/$(SHAREDLIB) $(RM) $(INSTALLDIRLIB)/$(STATICLIB) testgetgateway: testgetgateway.o getgateway.o $(CC) $(LDFLAGS) -o $@ $^ $(EXTRA_LD) natpmpc-static: natpmpc.o $(STATICLIB) $(CC) $(LDFLAGS) -o $@ $^ $(EXTRA_LD) natpmpc-shared: natpmpc.o $(SHAREDLIB) $(CC) $(LDFLAGS) -o $@ $^ $(EXTRA_LD) $(STATICLIB): $(LIBOBJS) $(AR) crs $@ $? $(SHAREDLIB): $(LIBOBJS) ifeq ($(OS), Darwin) $(CC) -dynamiclib -Wl,-install_name,$(SONAME) -o $@ $^ else $(CC) -shared -Wl,-soname,$(SONAME) -o $@ $^ $(EXTRA_LD) endif # DO NOT DELETE natpmp.o: natpmp.h getgateway.h declspec.h getgateway.o: getgateway.h declspec.h testgetgateway.o: getgateway.h declspec.h natpmpc.o: natpmp.h libnatpmp-20230423/getgateway.c010064400017500000024000000434711442121113700154350ustar00nanardstaff/* $Id: getgateway.c,v 1.26 2023/04/23 10:59:48 nanard Exp $ */ /* libnatpmp Copyright (c) 2007-2014, Thomas BERNARD All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include #include #ifndef _WIN32 #include #endif #if !defined(_MSC_VER) #include #endif /* There is no portable method to get the default route gateway. * So below are four (or five ?) differents functions implementing this. * Parsing /proc/net/route is for linux. * sysctl is the way to access such informations on BSD systems. * Many systems should provide route information through raw PF_ROUTE * sockets. * In MS Windows, default gateway is found by looking into the registry * or by using GetBestRoute(). */ #ifdef __linux__ #define USE_PROC_NET_ROUTE #undef USE_SOCKET_ROUTE #undef USE_SYSCTL_NET_ROUTE #endif #if defined(BSD) || defined(__FreeBSD_kernel__) #undef USE_PROC_NET_ROUTE #define USE_SOCKET_ROUTE #undef USE_SYSCTL_NET_ROUTE #endif #ifdef __APPLE__ #undef USE_PROC_NET_ROUTE #undef USE_SOCKET_ROUTE #define USE_SYSCTL_NET_ROUTE #endif #if (defined(sun) && defined(__SVR4)) #undef USE_PROC_NET_ROUTE #define USE_SOCKET_ROUTE #undef USE_SYSCTL_NET_ROUTE #endif #ifdef _WIN32 #undef USE_PROC_NET_ROUTE #undef USE_SOCKET_ROUTE #undef USE_SYSCTL_NET_ROUTE //#define USE_WIN32_CODE #define USE_WIN32_CODE_2 #endif #ifdef __CYGWIN__ #undef USE_PROC_NET_ROUTE #undef USE_SOCKET_ROUTE #undef USE_SYSCTL_NET_ROUTE #define USE_WIN32_CODE #include #include #include #include #endif #ifdef __HAIKU__ #include #include #include #include #define USE_HAIKU_CODE #endif #ifdef USE_SYSCTL_NET_ROUTE #include #include #include #include #endif #ifdef USE_SOCKET_ROUTE #include #include #include #include #include #endif #ifdef USE_WIN32_CODE #include #include #define MAX_KEY_LENGTH 255 #define MAX_VALUE_LENGTH 16383 #endif #ifdef USE_WIN32_CODE_2 #include #include #include #endif #include "getgateway.h" #ifndef _WIN32 #define SUCCESS (0) #define FAILED (-1) #endif #if defined(USE_PROC_NET_ROUTE) /* parse /proc/net/route which is as follow : Iface Destination Gateway Flags RefCnt Use Metric Mask MTU Window IRTT wlan0 0001A8C0 00000000 0001 0 0 0 00FFFFFF 0 0 0 eth0 0000FEA9 00000000 0001 0 0 0 0000FFFF 0 0 0 wlan0 00000000 0101A8C0 0003 0 0 0 00000000 0 0 0 eth0 00000000 00000000 0001 0 0 1000 00000000 0 0 0 One header line, and then one line by route by route table entry. */ int getdefaultgateway(in_addr_t * addr) { unsigned long d, g; char buf[256]; int line = 0; FILE * f; char * p; f = fopen("/proc/net/route", "r"); if(!f) return FAILED; while(fgets(buf, sizeof(buf), f)) { if(line > 0) { /* skip the first line */ p = buf; /* skip the interface name */ while(*p && !isspace(*p)) p++; while(*p && isspace(*p)) p++; if(sscanf(p, "%lx%lx", &d, &g)==2) { if(d == 0 && g != 0) { /* default */ *addr = g; fclose(f); return SUCCESS; } } } line++; } /* default route not found ! */ if(f) fclose(f); return FAILED; } #elif defined(USE_SYSCTL_NET_ROUTE) #define ROUNDUP(a) \ ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long)) int getdefaultgateway(in_addr_t * addr) { #if 0 /* net.route.0.inet.dump.0.0 ? */ int mib[] = {CTL_NET, PF_ROUTE, 0, AF_INET, NET_RT_DUMP, 0, 0/*tableid*/}; #endif /* net.route.0.inet.flags.gateway */ int mib[] = {CTL_NET, PF_ROUTE, 0, AF_INET, NET_RT_FLAGS, RTF_GATEWAY}; size_t l; char * buf, * p; struct rt_msghdr * rt; struct sockaddr * sa; struct sockaddr * sa_tab[RTAX_MAX]; int i; int r = FAILED; if(sysctl(mib, sizeof(mib)/sizeof(int), 0, &l, 0, 0) < 0) { return FAILED; } if(l>0) { buf = malloc(l); if(sysctl(mib, sizeof(mib)/sizeof(int), buf, &l, 0, 0) < 0) { free(buf); return FAILED; } for(p=buf; prtm_msglen) { rt = (struct rt_msghdr *)p; sa = (struct sockaddr *)(rt + 1); for(i=0; irtm_addrs & (1 << i)) { sa_tab[i] = sa; sa = (struct sockaddr *)((char *)sa + ROUNDUP(sa->sa_len)); } else { sa_tab[i] = NULL; } } if( ((rt->rtm_addrs & (RTA_DST|RTA_GATEWAY)) == (RTA_DST|RTA_GATEWAY)) && sa_tab[RTAX_DST]->sa_family == AF_INET && sa_tab[RTAX_GATEWAY]->sa_family == AF_INET) { if(((struct sockaddr_in *)sa_tab[RTAX_DST])->sin_addr.s_addr == 0) { *addr = ((struct sockaddr_in *)(sa_tab[RTAX_GATEWAY]))->sin_addr.s_addr; r = SUCCESS; } } } free(buf); } return r; } #elif defined(USE_SOCKET_ROUTE) /* Thanks to Darren Kenny for this code */ #define NEXTADDR(w, u) \ if (rtm_addrs & (w)) {\ l = sizeof(struct sockaddr); memmove(cp, &(u), l); cp += l;\ } #define rtm m_rtmsg.m_rtm struct { struct rt_msghdr m_rtm; char m_space[512]; } m_rtmsg; int getdefaultgateway(in_addr_t *addr) { int s, seq, l, rtm_addrs, i; pid_t pid; struct sockaddr so_dst, so_mask; char *cp = m_rtmsg.m_space; struct sockaddr *gate = NULL, *sa; struct rt_msghdr *msg_hdr; pid = getpid(); seq = 0; rtm_addrs = RTA_DST | RTA_NETMASK; memset(&so_dst, 0, sizeof(so_dst)); memset(&so_mask, 0, sizeof(so_mask)); memset(&rtm, 0, sizeof(struct rt_msghdr)); rtm.rtm_type = RTM_GET; rtm.rtm_flags = RTF_UP | RTF_GATEWAY; rtm.rtm_version = RTM_VERSION; rtm.rtm_seq = ++seq; rtm.rtm_addrs = rtm_addrs; so_dst.sa_family = AF_INET; so_dst.sa_len = sizeof(struct sockaddr); so_mask.sa_family = AF_INET; so_mask.sa_len = sizeof(struct sockaddr); NEXTADDR(RTA_DST, so_dst); NEXTADDR(RTA_NETMASK, so_mask); rtm.rtm_msglen = l = cp - (char *)&m_rtmsg; s = socket(PF_ROUTE, SOCK_RAW, 0); if (write(s, (char *)&m_rtmsg, l) < 0) { close(s); return FAILED; } do { l = read(s, (char *)&m_rtmsg, sizeof(m_rtmsg)); } while (l > 0 && (rtm.rtm_seq != seq || rtm.rtm_pid != pid)); close(s); msg_hdr = &rtm; cp = ((char *)(msg_hdr + 1)); if (msg_hdr->rtm_addrs) { for (i = 1; i; i <<= 1) if (i & msg_hdr->rtm_addrs) { sa = (struct sockaddr *)cp; if (i == RTA_GATEWAY ) gate = sa; cp += sizeof(struct sockaddr); } } else { return FAILED; } if (gate != NULL ) { *addr = ((struct sockaddr_in *)gate)->sin_addr.s_addr; return SUCCESS; } else { return FAILED; } } #elif defined(USE_WIN32_CODE) int getdefaultgateway(in_addr_t * addr) { HKEY networkCardsKey; HKEY networkCardKey; HKEY interfacesKey; HKEY interfaceKey; DWORD i = 0; DWORD numSubKeys = 0; TCHAR keyName[MAX_KEY_LENGTH]; DWORD keyNameLength = MAX_KEY_LENGTH; TCHAR keyValue[MAX_VALUE_LENGTH]; DWORD keyValueLength = MAX_VALUE_LENGTH; DWORD keyValueType = REG_SZ; TCHAR gatewayValue[MAX_VALUE_LENGTH]; DWORD gatewayValueLength = MAX_VALUE_LENGTH; DWORD gatewayValueType = REG_MULTI_SZ; int done = 0; //const char * networkCardsPath = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\NetworkCards"; //const char * interfacesPath = "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces"; #ifdef UNICODE LPCTSTR networkCardsPath = L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\NetworkCards"; LPCTSTR interfacesPath = L"SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces"; #define STR_SERVICENAME L"ServiceName" #define STR_DHCPDEFAULTGATEWAY L"DhcpDefaultGateway" #define STR_DEFAULTGATEWAY L"DefaultGateway" #else LPCTSTR networkCardsPath = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\NetworkCards"; LPCTSTR interfacesPath = "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces"; #define STR_SERVICENAME "ServiceName" #define STR_DHCPDEFAULTGATEWAY "DhcpDefaultGateway" #define STR_DEFAULTGATEWAY "DefaultGateway" #endif // The windows registry lists its primary network devices in the following location: // HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\NetworkCards // // Each network device has its own subfolder, named with an index, with various properties: // -NetworkCards // -5 // -Description = Broadcom 802.11n Network Adapter // -ServiceName = {E35A72F8-5065-4097-8DFE-C7790774EE4D} // -8 // -Description = Marvell Yukon 88E8058 PCI-E Gigabit Ethernet Controller // -ServiceName = {86226414-5545-4335-A9D1-5BD7120119AD} // // The above service name is the name of a subfolder within: // HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\Interfaces // // There may be more subfolders in this interfaces path than listed in the network cards path above: // -Interfaces // -{3a539854-6a70-11db-887c-806e6f6e6963} // -DhcpIPAddress = 0.0.0.0 // -[more] // -{E35A72F8-5065-4097-8DFE-C7790774EE4D} // -DhcpIPAddress = 10.0.1.4 // -DhcpDefaultGateway = 10.0.1.1 // -[more] // -{86226414-5545-4335-A9D1-5BD7120119AD} // -DhcpIpAddress = 10.0.1.5 // -DhcpDefaultGateay = 10.0.1.1 // -[more] // // In order to extract this information, we enumerate each network card, and extract the ServiceName value. // This is then used to open the interface subfolder, and attempt to extract a DhcpDefaultGateway value. // Once one is found, we're done. // // It may be possible to simply enumerate the interface folders until we find one with a DhcpDefaultGateway value. // However, the technique used is the technique most cited on the web, and we assume it to be more correct. if(ERROR_SUCCESS != RegOpenKeyEx(HKEY_LOCAL_MACHINE, // Open registry key or predifined key networkCardsPath, // Name of registry subkey to open 0, // Reserved - must be zero KEY_READ, // Mask - desired access rights &networkCardsKey)) // Pointer to output key { // Unable to open network cards keys return -1; } if(ERROR_SUCCESS != RegOpenKeyEx(HKEY_LOCAL_MACHINE, // Open registry key or predefined key interfacesPath, // Name of registry subkey to open 0, // Reserved - must be zero KEY_READ, // Mask - desired access rights &interfacesKey)) // Pointer to output key { // Unable to open interfaces key RegCloseKey(networkCardsKey); return -1; } // Figure out how many subfolders are within the NetworkCards folder RegQueryInfoKey(networkCardsKey, NULL, NULL, NULL, &numSubKeys, NULL, NULL, NULL, NULL, NULL, NULL, NULL); //printf( "Number of subkeys: %u\n", (unsigned int)numSubKeys); // Enumrate through each subfolder within the NetworkCards folder for(i = 0; i < numSubKeys && !done; i++) { keyNameLength = MAX_KEY_LENGTH; if(ERROR_SUCCESS == RegEnumKeyEx(networkCardsKey, // Open registry key i, // Index of subkey to retrieve keyName, // Buffer that receives the name of the subkey &keyNameLength, // Variable that receives the size of the above buffer NULL, // Reserved - must be NULL NULL, // Buffer that receives the class string NULL, // Variable that receives the size of the above buffer NULL)) // Variable that receives the last write time of subkey { if(RegOpenKeyEx(networkCardsKey, keyName, 0, KEY_READ, &networkCardKey) == ERROR_SUCCESS) { keyValueLength = MAX_VALUE_LENGTH; if(ERROR_SUCCESS == RegQueryValueEx(networkCardKey, // Open registry key STR_SERVICENAME, // Name of key to query NULL, // Reserved - must be NULL &keyValueType, // Receives value type (LPBYTE)keyValue, // Receives value &keyValueLength)) // Receives value length in bytes { // printf("keyValue: %s\n", keyValue); if(RegOpenKeyEx(interfacesKey, keyValue, 0, KEY_READ, &interfaceKey) == ERROR_SUCCESS) { gatewayValueLength = MAX_VALUE_LENGTH; if(ERROR_SUCCESS == RegQueryValueEx(interfaceKey, // Open registry key STR_DHCPDEFAULTGATEWAY, // Name of key to query NULL, // Reserved - must be NULL &gatewayValueType, // Receives value type (LPBYTE)gatewayValue, // Receives value &gatewayValueLength)) // Receives value length in bytes { // Check to make sure it's a string if((gatewayValueType == REG_MULTI_SZ || gatewayValueType == REG_SZ) && (gatewayValueLength > 1)) { //printf("gatewayValue: %s\n", gatewayValue); done = 1; } } else if(ERROR_SUCCESS == RegQueryValueEx(interfaceKey, // Open registry key STR_DEFAULTGATEWAY, // Name of key to query NULL, // Reserved - must be NULL &gatewayValueType, // Receives value type (LPBYTE)gatewayValue,// Receives value &gatewayValueLength)) // Receives value length in bytes { // Check to make sure it's a string if((gatewayValueType == REG_MULTI_SZ || gatewayValueType == REG_SZ) && (gatewayValueLength > 1)) { //printf("gatewayValue: %s\n", gatewayValue); done = 1; } } RegCloseKey(interfaceKey); } } RegCloseKey(networkCardKey); } } } RegCloseKey(interfacesKey); RegCloseKey(networkCardsKey); if(done) { #if UNICODE char tmp[32]; for(i = 0; i < 32; i++) { tmp[i] = (char)gatewayValue[i]; if(!tmp[i]) break; } tmp[31] = '\0'; *addr = inet_addr(tmp); #else *addr = inet_addr(gatewayValue); #endif return 0; } return -1; } #elif defined(USE_WIN32_CODE_2) int getdefaultgateway(in_addr_t *addr) { MIB_IPFORWARDROW ip_forward; memset(&ip_forward, 0, sizeof(ip_forward)); if(GetBestRoute(inet_addr("0.0.0.0"), 0, &ip_forward) != NO_ERROR) return -1; *addr = ip_forward.dwForwardNextHop; return 0; } #elif defined(USE_HAIKU_CODE) int getdefaultgateway(in_addr_t *addr) { int fd, ret = -1; struct ifconf config; void *buffer = NULL; struct ifreq *interface; if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { return -1; } if (ioctl(fd, SIOCGRTSIZE, &config, sizeof(config)) != 0) { goto fail; } if (config.ifc_value < 1) { goto fail; /* No routes */ } if ((buffer = malloc(config.ifc_value)) == NULL) { goto fail; } config.ifc_len = config.ifc_value; config.ifc_buf = buffer; if (ioctl(fd, SIOCGRTTABLE, &config, sizeof(config)) != 0) { goto fail; } for (interface = buffer; (uint8_t *)interface < (uint8_t *)buffer + config.ifc_len; ) { struct route_entry route = interface->ifr_route; int intfSize; if (route.flags & (RTF_GATEWAY | RTF_DEFAULT)) { *addr = ((struct sockaddr_in *)route.gateway)->sin_addr.s_addr; ret = 0; break; } intfSize = sizeof(route) + IF_NAMESIZE; if (route.destination != NULL) { intfSize += route.destination->sa_len; } if (route.mask != NULL) { intfSize += route.mask->sa_len; } if (route.gateway != NULL) { intfSize += route.gateway->sa_len; } interface = (struct ifreq *)((uint8_t *)interface + intfSize); } fail: free(buffer); close(fd); return ret; } #else /* fallback */ int getdefaultgateway(in_addr_t * addr) { (void)addr; return -1; } #endif libnatpmp-20230423/getgateway.h010064400017500000024000000036631442121113700154410ustar00nanardstaff/* $Id: getgateway.h,v 1.9 2023/04/23 10:59:17 nanard Exp $ */ /* libnatpmp Copyright (c) 2007-2014, Thomas BERNARD All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #ifndef __GETGATEWAY_H__ #define __GETGATEWAY_H__ #ifdef _WIN32 #if !defined(_MSC_VER) || _MSC_VER >= 1600 #include #else typedef unsigned long uint32_t; typedef unsigned short uint16_t; #endif #define in_addr_t uint32_t #endif /* #include "declspec.h" */ /* getdefaultgateway() : * return value : * 0 : success * -1 : failure */ /* NATPMP_LIBSPEC */int getdefaultgateway(in_addr_t * addr); #endif libnatpmp-20230423/natpmp.c010064400017500000024000000254271442121113700145740ustar00nanardstaff/* $Id: natpmp.c,v 1.21 2023/04/23 10:50:11 nanard Exp $ */ /* libnatpmp Copyright (c) 2007-2018, Thomas BERNARD All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #ifdef __linux__ #define _DEFAULT_SOURCE 1 #endif #include #include #if !defined(_MSC_VER) #include #endif #ifdef _WIN32 #include #include #include #include #ifdef EWOULDBLOCK #undef EWOULDBLOCK #endif #ifdef ECONNREFUSED #undef ECONNREFUSED #endif #define EWOULDBLOCK WSAEWOULDBLOCK #define ECONNREFUSED WSAECONNREFUSED #include "wingettimeofday.h" #define gettimeofday natpmp_gettimeofday #else #include #include #include #include #include #define closesocket close #endif #include "natpmp.h" #include "getgateway.h" #include NATPMP_LIBSPEC int initnatpmp(natpmp_t * p, int forcegw, in_addr_t forcedgw) { #ifdef _WIN32 u_long ioctlArg = 1; #else int flags; #endif struct sockaddr_in addr; if(!p) return NATPMP_ERR_INVALIDARGS; memset(p, 0, sizeof(natpmp_t)); p->s = socket(PF_INET, SOCK_DGRAM, 0); if(p->s < 0) return NATPMP_ERR_SOCKETERROR; #ifdef _WIN32 if(ioctlsocket(p->s, FIONBIO, &ioctlArg) == SOCKET_ERROR) return NATPMP_ERR_FCNTLERROR; #else if((flags = fcntl(p->s, F_GETFL, 0)) < 0) return NATPMP_ERR_FCNTLERROR; if(fcntl(p->s, F_SETFL, flags | O_NONBLOCK) < 0) return NATPMP_ERR_FCNTLERROR; #endif if(forcegw) { p->gateway = forcedgw; } else { if(getdefaultgateway(&(p->gateway)) < 0) return NATPMP_ERR_CANNOTGETGATEWAY; } memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_port = htons(NATPMP_PORT); addr.sin_addr.s_addr = p->gateway; if(connect(p->s, (struct sockaddr *)&addr, sizeof(addr)) < 0) return NATPMP_ERR_CONNECTERR; return 0; } NATPMP_LIBSPEC int closenatpmp(natpmp_t * p) { if(!p) return NATPMP_ERR_INVALIDARGS; if(closesocket(p->s) < 0) return NATPMP_ERR_CLOSEERR; return 0; } int sendpendingrequest(natpmp_t * p) { int r; /* struct sockaddr_in addr;*/ if(!p) return NATPMP_ERR_INVALIDARGS; /* memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_port = htons(NATPMP_PORT); addr.sin_addr.s_addr = p->gateway; r = (int)sendto(p->s, p->pending_request, p->pending_request_len, 0, (struct sockaddr *)&addr, sizeof(addr));*/ r = (int)send(p->s, p->pending_request, p->pending_request_len, 0); return (r<0) ? NATPMP_ERR_SENDERR : r; } int sendnatpmprequest(natpmp_t * p) { int n; if(!p) return NATPMP_ERR_INVALIDARGS; /* TODO : check if no request is already pending */ p->has_pending_request = 1; p->try_number = 1; n = sendpendingrequest(p); gettimeofday(&p->retry_time, NULL); // check errors ! p->retry_time.tv_usec += 250000; /* add 250ms */ if(p->retry_time.tv_usec >= 1000000) { p->retry_time.tv_usec -= 1000000; p->retry_time.tv_sec++; } return n; } NATPMP_LIBSPEC int getnatpmprequesttimeout(natpmp_t * p, struct timeval * timeout) { struct timeval now; if(!p || !timeout) return NATPMP_ERR_INVALIDARGS; if(!p->has_pending_request) return NATPMP_ERR_NOPENDINGREQ; if(gettimeofday(&now, NULL) < 0) return NATPMP_ERR_GETTIMEOFDAYERR; timeout->tv_sec = p->retry_time.tv_sec - now.tv_sec; timeout->tv_usec = p->retry_time.tv_usec - now.tv_usec; if(timeout->tv_usec < 0) { timeout->tv_usec += 1000000; timeout->tv_sec--; } return 0; } NATPMP_LIBSPEC int sendpublicaddressrequest(natpmp_t * p) { if(!p) return NATPMP_ERR_INVALIDARGS; //static const unsigned char request[] = { 0, 0 }; p->pending_request[0] = 0; p->pending_request[1] = 0; p->pending_request_len = 2; // TODO: return 0 instead of sizeof(request) ?? return sendnatpmprequest(p); } NATPMP_LIBSPEC int sendnewportmappingrequest(natpmp_t * p, int protocol, uint16_t privateport, uint16_t publicport, uint32_t lifetime) { if(!p || (protocol!=NATPMP_PROTOCOL_TCP && protocol!=NATPMP_PROTOCOL_UDP)) return NATPMP_ERR_INVALIDARGS; p->pending_request[0] = 0; p->pending_request[1] = protocol; p->pending_request[2] = 0; p->pending_request[3] = 0; /* break strict-aliasing rules : *((uint16_t *)(p->pending_request + 4)) = htons(privateport); */ p->pending_request[4] = (privateport >> 8) & 0xff; p->pending_request[5] = privateport & 0xff; /* break stric-aliasing rules : *((uint16_t *)(p->pending_request + 6)) = htons(publicport); */ p->pending_request[6] = (publicport >> 8) & 0xff; p->pending_request[7] = publicport & 0xff; /* break stric-aliasing rules : *((uint32_t *)(p->pending_request + 8)) = htonl(lifetime); */ p->pending_request[8] = (lifetime >> 24) & 0xff; p->pending_request[9] = (lifetime >> 16) & 0xff; p->pending_request[10] = (lifetime >> 8) & 0xff; p->pending_request[11] = lifetime & 0xff; p->pending_request_len = 12; return sendnatpmprequest(p); } NATPMP_LIBSPEC int readnatpmpresponse(natpmp_t * p, natpmpresp_t * response) { unsigned char buf[16]; struct sockaddr_in addr; socklen_t addrlen = sizeof(addr); #ifdef _WIN32 int n; #else ssize_t n; #endif if(!p) return NATPMP_ERR_INVALIDARGS; n = recvfrom(p->s, buf, sizeof(buf), 0, (struct sockaddr *)&addr, &addrlen); if(n<0) #ifdef _WIN32 switch(WSAGetLastError()) { #else switch(errno) { #endif /*case EAGAIN:*/ case EWOULDBLOCK: n = NATPMP_TRYAGAIN; break; case ECONNREFUSED: n = NATPMP_ERR_NOGATEWAYSUPPORT; break; default: n = NATPMP_ERR_RECVFROM; } /* check that addr is correct (= gateway) */ else if(addr.sin_addr.s_addr != p->gateway) n = NATPMP_ERR_WRONGPACKETSOURCE; else { response->resultcode = ntohs(*((uint16_t *)(buf + 2))); response->epoch = ntohl(*((uint32_t *)(buf + 4))); if(buf[0] != 0) n = NATPMP_ERR_UNSUPPORTEDVERSION; else if(buf[1] < 128 || buf[1] > 130) n = NATPMP_ERR_UNSUPPORTEDOPCODE; else if(response->resultcode != 0) { switch(response->resultcode) { case 1: n = NATPMP_ERR_UNSUPPORTEDVERSION; break; case 2: n = NATPMP_ERR_NOTAUTHORIZED; break; case 3: n = NATPMP_ERR_NETWORKFAILURE; break; case 4: n = NATPMP_ERR_OUTOFRESOURCES; break; case 5: n = NATPMP_ERR_UNSUPPORTEDOPCODE; break; default: n = NATPMP_ERR_UNDEFINEDERROR; } } else { response->type = buf[1] & 0x7f; if(buf[1] == 128) { //response->publicaddress.addr = *((uint32_t *)(buf + 8)); response->pnu.publicaddress.addr.s_addr = *((uint32_t *)(buf + 8)); n = 0; } else { /* check that the private port matches our current request */ if(*(uint16_t*)(p->pending_request + 4) == *((uint16_t*)(buf + 8))) { response->pnu.newportmapping.privateport = ntohs(*((uint16_t*)(buf + 8))); response->pnu.newportmapping.mappedpublicport = ntohs(*((uint16_t*)(buf + 10))); response->pnu.newportmapping.lifetime = ntohl(*((uint32_t*)(buf + 12))); n = 0; } else { /* ignore the old response and continue waiting */ n = NATPMP_TRYAGAIN; } } } } return n; } NATPMP_LIBSPEC int readnatpmpresponseorretry(natpmp_t * p, natpmpresp_t * response) { int n; if(!p || !response) return NATPMP_ERR_INVALIDARGS; if(!p->has_pending_request) return NATPMP_ERR_NOPENDINGREQ; n = readnatpmpresponse(p, response); if(n<0) { if(n==NATPMP_TRYAGAIN) { struct timeval now; gettimeofday(&now, NULL); // check errors ! if(timercmp(&now, &p->retry_time, >=)) { int delay, r; if(p->try_number >= NATPMP_MAX_RETRIES) { return NATPMP_ERR_NOGATEWAYSUPPORT; } /*printf("retry! %d\n", p->try_number);*/ delay = 250 * (1<try_number); // ms /*for(i=0; itry_number; i++) delay += delay;*/ p->retry_time.tv_sec += (delay / 1000); p->retry_time.tv_usec += (delay % 1000) * 1000; if(p->retry_time.tv_usec >= 1000000) { p->retry_time.tv_usec -= 1000000; p->retry_time.tv_sec++; } p->try_number++; r = sendpendingrequest(p); if(r<0) return r; } } } else { p->has_pending_request = 0; } return n; } #ifdef ENABLE_STRNATPMPERR NATPMP_LIBSPEC const char * strnatpmperr(int r) { const char * s; switch(r) { case NATPMP_ERR_INVALIDARGS: s = "invalid arguments"; break; case NATPMP_ERR_SOCKETERROR: s = "socket() failed"; break; case NATPMP_ERR_CANNOTGETGATEWAY: s = "cannot get default gateway ip address"; break; case NATPMP_ERR_CLOSEERR: #ifdef _WIN32 s = "closesocket() failed"; #else s = "close() failed"; #endif break; case NATPMP_ERR_RECVFROM: s = "recvfrom() failed"; break; case NATPMP_ERR_NOPENDINGREQ: s = "no pending request"; break; case NATPMP_ERR_NOGATEWAYSUPPORT: s = "the gateway does not support nat-pmp"; break; case NATPMP_ERR_CONNECTERR: s = "connect() failed"; break; case NATPMP_ERR_WRONGPACKETSOURCE: s = "packet not received from the default gateway"; break; case NATPMP_ERR_SENDERR: s = "send() failed"; break; case NATPMP_ERR_FCNTLERROR: s = "fcntl() failed"; break; case NATPMP_ERR_GETTIMEOFDAYERR: s = "gettimeofday() failed"; break; case NATPMP_ERR_UNSUPPORTEDVERSION: s = "unsupported nat-pmp version error from server"; break; case NATPMP_ERR_UNSUPPORTEDOPCODE: s = "unsupported nat-pmp opcode error from server"; break; case NATPMP_ERR_UNDEFINEDERROR: s = "undefined nat-pmp server error"; break; case NATPMP_ERR_NOTAUTHORIZED: s = "not authorized"; break; case NATPMP_ERR_NETWORKFAILURE: s = "network failure"; break; case NATPMP_ERR_OUTOFRESOURCES: s = "nat-pmp server out of resources"; break; default: s = "Unknown libnatpmp error"; } return s; } #endif libnatpmp-20230423/natpmp.h010064400017500000024000000166421442121113700146000ustar00nanardstaff/* $Id: natpmp.h,v 1.22 2023/04/23 10:50:11 nanard Exp $ */ /* libnatpmp Copyright (c) 2007-2014, Thomas BERNARD All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #ifndef __NATPMP_H__ #define __NATPMP_H__ /* NAT-PMP Port as defined by the NAT-PMP draft */ #define NATPMP_PORT (5351) #include #if !defined(_MSC_VER) #include #endif /* !defined(_MSC_VER) */ #ifdef _WIN32 #include #if !defined(_MSC_VER) || _MSC_VER >= 1600 #include #else /* !defined(_MSC_VER) || _MSC_VER >= 1600 */ typedef unsigned long uint32_t; typedef unsigned short uint16_t; #endif /* !defined(_MSC_VER) || _MSC_VER >= 1600 */ #define in_addr_t uint32_t #else /* _WIN32 */ #include #endif /* _WIN32 */ #include "natpmp_declspec.h" /* Set to 9 by https://tools.ietf.org/html/rfc6886#section-3.1 which leads to a * maximum timeout of 127.75 seconds, due to the initial 250 ms timeout doubling * each time, so we allow a compile-time modification here.*/ #ifndef NATPMP_MAX_RETRIES #define NATPMP_MAX_RETRIES (9) #endif typedef struct { int s; /* socket */ in_addr_t gateway; /* default gateway (IPv4) */ int has_pending_request; unsigned char pending_request[12]; int pending_request_len; int try_number; struct timeval retry_time; } natpmp_t; typedef struct { uint16_t type; /* NATPMP_RESPTYPE_* */ uint16_t resultcode; /* NAT-PMP response code */ uint32_t epoch; /* Seconds since start of epoch */ union { struct { //in_addr_t addr; struct in_addr addr; } publicaddress; struct { uint16_t privateport; uint16_t mappedpublicport; uint32_t lifetime; } newportmapping; } pnu; } natpmpresp_t; /* possible values for type field of natpmpresp_t */ #define NATPMP_RESPTYPE_PUBLICADDRESS (0) #define NATPMP_RESPTYPE_UDPPORTMAPPING (1) #define NATPMP_RESPTYPE_TCPPORTMAPPING (2) /* Values to pass to sendnewportmappingrequest() */ #define NATPMP_PROTOCOL_UDP (1) #define NATPMP_PROTOCOL_TCP (2) /* return values */ /* NATPMP_ERR_INVALIDARGS : invalid arguments passed to the function */ #define NATPMP_ERR_INVALIDARGS (-1) /* NATPMP_ERR_SOCKETERROR : socket() failed. check errno for details */ #define NATPMP_ERR_SOCKETERROR (-2) /* NATPMP_ERR_CANNOTGETGATEWAY : can't get default gateway IP */ #define NATPMP_ERR_CANNOTGETGATEWAY (-3) /* NATPMP_ERR_CLOSEERR : close() failed. check errno for details */ #define NATPMP_ERR_CLOSEERR (-4) /* NATPMP_ERR_RECVFROM : recvfrom() failed. check errno for details */ #define NATPMP_ERR_RECVFROM (-5) /* NATPMP_ERR_NOPENDINGREQ : readnatpmpresponseorretry() called while * no NAT-PMP request was pending */ #define NATPMP_ERR_NOPENDINGREQ (-6) /* NATPMP_ERR_NOGATEWAYSUPPORT : the gateway does not support NAT-PMP */ #define NATPMP_ERR_NOGATEWAYSUPPORT (-7) /* NATPMP_ERR_CONNECTERR : connect() failed. check errno for details */ #define NATPMP_ERR_CONNECTERR (-8) /* NATPMP_ERR_WRONGPACKETSOURCE : packet not received from the network gateway */ #define NATPMP_ERR_WRONGPACKETSOURCE (-9) /* NATPMP_ERR_SENDERR : send() failed. check errno for details */ #define NATPMP_ERR_SENDERR (-10) /* NATPMP_ERR_FCNTLERROR : fcntl() failed. check errno for details */ #define NATPMP_ERR_FCNTLERROR (-11) /* NATPMP_ERR_GETTIMEOFDAYERR : gettimeofday() failed. check errno for details */ #define NATPMP_ERR_GETTIMEOFDAYERR (-12) /* */ #define NATPMP_ERR_UNSUPPORTEDVERSION (-14) #define NATPMP_ERR_UNSUPPORTEDOPCODE (-15) /* Errors from the server : */ #define NATPMP_ERR_UNDEFINEDERROR (-49) #define NATPMP_ERR_NOTAUTHORIZED (-51) #define NATPMP_ERR_NETWORKFAILURE (-52) #define NATPMP_ERR_OUTOFRESOURCES (-53) /* NATPMP_TRYAGAIN : no data available for the moment. try again later */ #define NATPMP_TRYAGAIN (-100) #ifdef __cplusplus extern "C" { #endif /* initnatpmp() * initialize a natpmp_t object * With forcegw=1 the gateway is not detected automaticaly. * Return values : * 0 = OK * NATPMP_ERR_INVALIDARGS * NATPMP_ERR_SOCKETERROR * NATPMP_ERR_FCNTLERROR * NATPMP_ERR_CANNOTGETGATEWAY * NATPMP_ERR_CONNECTERR */ NATPMP_LIBSPEC int initnatpmp(natpmp_t * p, int forcegw, in_addr_t forcedgw); /* closenatpmp() * close resources associated with a natpmp_t object * Return values : * 0 = OK * NATPMP_ERR_INVALIDARGS * NATPMP_ERR_CLOSEERR */ NATPMP_LIBSPEC int closenatpmp(natpmp_t * p); /* sendpublicaddressrequest() * send a public address NAT-PMP request to the network gateway * Return values : * 2 = OK (size of the request) * NATPMP_ERR_INVALIDARGS * NATPMP_ERR_SENDERR */ NATPMP_LIBSPEC int sendpublicaddressrequest(natpmp_t * p); /* sendnewportmappingrequest() * send a new port mapping NAT-PMP request to the network gateway * Arguments : * protocol is either NATPMP_PROTOCOL_TCP or NATPMP_PROTOCOL_UDP, * lifetime is in seconds. * To remove a port mapping, set lifetime to zero. * To remove all port mappings to the host, set lifetime and both ports * to zero. * Return values : * 12 = OK (size of the request) * NATPMP_ERR_INVALIDARGS * NATPMP_ERR_SENDERR */ NATPMP_LIBSPEC int sendnewportmappingrequest(natpmp_t * p, int protocol, uint16_t privateport, uint16_t publicport, uint32_t lifetime); /* getnatpmprequesttimeout() * fills the timeval structure with the timeout duration of the * currently pending NAT-PMP request. * Return values : * 0 = OK * NATPMP_ERR_INVALIDARGS * NATPMP_ERR_GETTIMEOFDAYERR * NATPMP_ERR_NOPENDINGREQ */ NATPMP_LIBSPEC int getnatpmprequesttimeout(natpmp_t * p, struct timeval * timeout); /* readnatpmpresponseorretry() * fills the natpmpresp_t structure if possible * Return values : * 0 = OK * NATPMP_TRYAGAIN * NATPMP_ERR_INVALIDARGS * NATPMP_ERR_NOPENDINGREQ * NATPMP_ERR_NOGATEWAYSUPPORT * NATPMP_ERR_RECVFROM * NATPMP_ERR_WRONGPACKETSOURCE * NATPMP_ERR_UNSUPPORTEDVERSION * NATPMP_ERR_UNSUPPORTEDOPCODE * NATPMP_ERR_NOTAUTHORIZED * NATPMP_ERR_NETWORKFAILURE * NATPMP_ERR_OUTOFRESOURCES * NATPMP_ERR_UNSUPPORTEDOPCODE * NATPMP_ERR_UNDEFINEDERROR */ NATPMP_LIBSPEC int readnatpmpresponseorretry(natpmp_t * p, natpmpresp_t * response); #ifdef ENABLE_STRNATPMPERR NATPMP_LIBSPEC const char * strnatpmperr(int t); #endif #ifdef __cplusplus } #endif #endif libnatpmp-20230423/natpmpc.c010064400017500000024000000237721442121113700147400ustar00nanardstaff/* $Id: natpmpc.c,v 1.14 2023/04/23 10:56:47 nanard Exp $ */ /* libnatpmp Copyright (c) 2007-2011, Thomas BERNARD All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include #include #include #if defined(_MSC_VER) #if _MSC_VER >= 1400 #define strcasecmp _stricmp #else #define strcasecmp stricmp #endif #else #include #endif #ifdef _WIN32 #include #else #include #include #endif #include "natpmp.h" /* List of IP address blocks which are private / reserved and therefore not suitable for public external IP addresses */ #define IP(a, b, c, d) (((a) << 24) + ((b) << 16) + ((c) << 8) + (d)) #define MSK(m) (32-(m)) static const struct { uint32_t address; uint32_t rmask; } reserved[] = { { IP( 0, 0, 0, 0), MSK( 8) }, /* RFC1122 "This host on this network" */ { IP( 10, 0, 0, 0), MSK( 8) }, /* RFC1918 Private-Use */ { IP(100, 64, 0, 0), MSK(10) }, /* RFC6598 Shared Address Space */ { IP(127, 0, 0, 0), MSK( 8) }, /* RFC1122 Loopback */ { IP(169, 254, 0, 0), MSK(16) }, /* RFC3927 Link-Local */ { IP(172, 16, 0, 0), MSK(12) }, /* RFC1918 Private-Use */ { IP(192, 0, 0, 0), MSK(24) }, /* RFC6890 IETF Protocol Assignments */ { IP(192, 0, 2, 0), MSK(24) }, /* RFC5737 Documentation (TEST-NET-1) */ { IP(192, 31, 196, 0), MSK(24) }, /* RFC7535 AS112-v4 */ { IP(192, 52, 193, 0), MSK(24) }, /* RFC7450 AMT */ { IP(192, 88, 99, 0), MSK(24) }, /* RFC7526 6to4 Relay Anycast */ { IP(192, 168, 0, 0), MSK(16) }, /* RFC1918 Private-Use */ { IP(192, 175, 48, 0), MSK(24) }, /* RFC7534 Direct Delegation AS112 Service */ { IP(198, 18, 0, 0), MSK(15) }, /* RFC2544 Benchmarking */ { IP(198, 51, 100, 0), MSK(24) }, /* RFC5737 Documentation (TEST-NET-2) */ { IP(203, 0, 113, 0), MSK(24) }, /* RFC5737 Documentation (TEST-NET-3) */ { IP(224, 0, 0, 0), MSK( 4) }, /* RFC1112 Multicast */ { IP(240, 0, 0, 0), MSK( 4) }, /* RFC1112 Reserved for Future Use + RFC919 Limited Broadcast */ }; #undef IP #undef MSK static int addr_is_reserved(struct in_addr * addr) { uint32_t address = ntohl(addr->s_addr); size_t i; for (i = 0; i < sizeof(reserved)/sizeof(reserved[0]); ++i) { if ((address >> reserved[i].rmask) == (reserved[i].address >> reserved[i].rmask)) return 1; } return 0; } void usage(FILE * out, const char * argv0) { fprintf(out, "Usage :\n" " %s [options]\n" "\tdisplay the public IP address.\n" " %s -h\n" "\tdisplay this help screen.\n" " %s [options] -a [lifetime]\n" "\tadd a port mapping.\n" "\nOption available :\n" " -g ipv4address\n" "\tforce the gateway to be used as destination for NAT-PMP commands.\n" "\n In order to remove a mapping, set it with a lifetime of 0 seconds.\n" " To remove all mappings for your machine, use 0 as private port and lifetime.\n", argv0, argv0, argv0); } static void handlenatpmpbadreplytype(natpmp_t* pnatpmp, const natpmpresp_t* presponse, int* preturncode){ char retry = (pnatpmp->try_number <= 9); printf("readnatpmpresponseorretry received unexpected reply type %hu , %s...\n", presponse->type, (retry == 1 ? "retrying" : "no more retry")); if (retry) { *preturncode = NATPMP_TRYAGAIN; pnatpmp->has_pending_request = 1; } } /* sample code for using libnatpmp */ int main(int argc, char * * argv) { natpmp_t natpmp; natpmpresp_t response; int r; int sav_errno; struct timeval timeout; fd_set fds; int i; int protocol = 0; uint16_t privateport = 0; uint16_t publicport = 0; uint32_t lifetime = 3600; int command = 0; int forcegw = 0; in_addr_t gateway = 0; struct in_addr gateway_in_use; #ifdef _WIN32 WSADATA wsaData; int nResult = WSAStartup(MAKEWORD(2,2), &wsaData); if(nResult != NO_ERROR) { fprintf(stderr, "WSAStartup() failed.\n"); return -1; } #endif /* argument parsing */ for(i=1; i i + 1) { if(1 != sscanf(argv[i+1], "%u", &lifetime)) { fprintf(stderr, "%s is not a correct 32bits unsigned integer\n", argv[i]); } else { i++; } } break; default: fprintf(stderr, "Unknown option %s\n", argv[i]); usage(stderr, argv[0]); return 1; } } else { fprintf(stderr, "Unknown option %s\n", argv[i]); usage(stderr, argv[0]); return 1; } } /* initnatpmp() */ r = initnatpmp(&natpmp, forcegw, gateway); printf("initnatpmp() returned %d (%s)\n", r, r?"FAILED":"SUCCESS"); if(r<0) return 1; gateway_in_use.s_addr = natpmp.gateway; printf("using gateway : %s\n", inet_ntoa(gateway_in_use)); /* sendpublicaddressrequest() */ r = sendpublicaddressrequest(&natpmp); printf("sendpublicaddressrequest returned %d (%s)\n", r, r==2?"SUCCESS":"FAILED"); if(r<0) return 1; do { FD_ZERO(&fds); FD_SET(natpmp.s, &fds); getnatpmprequesttimeout(&natpmp, &timeout); r = select(FD_SETSIZE, &fds, NULL, NULL, &timeout); if(r<0) { fprintf(stderr, "select()"); return 1; } r = readnatpmpresponseorretry(&natpmp, &response); sav_errno = errno; printf("readnatpmpresponseorretry returned %d (%s)\n", r, r==0?"OK":(r==NATPMP_TRYAGAIN?"TRY AGAIN":"FAILED")); if(r<0 && r!=NATPMP_TRYAGAIN) { #ifdef ENABLE_STRNATPMPERR fprintf(stderr, "readnatpmpresponseorretry() failed : %s\n", strnatpmperr(r)); #endif fprintf(stderr, " errno=%d '%s'\n", sav_errno, strerror(sav_errno)); } if (r >= 0 && response.type != 0) { handlenatpmpbadreplytype(&natpmp, &response, &r); } } while(r==NATPMP_TRYAGAIN); if(r<0) return 1; if(response.type!=NATPMP_RESPTYPE_PUBLICADDRESS) { fprintf(stderr, "readnatpmpresponseorretry() failed : invalid response type %u\n", response.type); return 1; } if(addr_is_reserved(&response.pnu.publicaddress.addr)) { fprintf(stderr, "readnatpmpresponseorretry() failed : invalid Public IP address %s\n", inet_ntoa(response.pnu.publicaddress.addr)); return 1; } printf("Public IP address : %s\n", inet_ntoa(response.pnu.publicaddress.addr)); printf("epoch = %u\n", response.epoch); if(command == 'a') { /* sendnewportmappingrequest() */ r = sendnewportmappingrequest(&natpmp, protocol, privateport, publicport, lifetime); printf("sendnewportmappingrequest returned %d (%s)\n", r, r==12?"SUCCESS":"FAILED"); if(r < 0) return 1; do { FD_ZERO(&fds); FD_SET(natpmp.s, &fds); getnatpmprequesttimeout(&natpmp, &timeout); select(FD_SETSIZE, &fds, NULL, NULL, &timeout); r = readnatpmpresponseorretry(&natpmp, &response); printf("readnatpmpresponseorretry returned %d (%s)\n", r, r==0?"OK":(r==NATPMP_TRYAGAIN?"TRY AGAIN":"FAILED")); if (r >= 0 && ( protocol == NATPMP_PROTOCOL_TCP && response.type != NATPMP_RESPTYPE_TCPPORTMAPPING || protocol == NATPMP_PROTOCOL_UDP && response.type != NATPMP_RESPTYPE_UDPPORTMAPPING)) { handlenatpmpbadreplytype(&natpmp, &response, &r); } } while(r==NATPMP_TRYAGAIN); if(r<0) { #ifdef ENABLE_STRNATPMPERR fprintf(stderr, "readnatpmpresponseorretry() failed : %s\n", strnatpmperr(r)); #endif return 1; } printf("Mapped public port %hu protocol %s to local port %hu " "lifetime %u\n", response.pnu.newportmapping.mappedpublicport, response.type == NATPMP_RESPTYPE_UDPPORTMAPPING ? "UDP" : (response.type == NATPMP_RESPTYPE_TCPPORTMAPPING ? "TCP" : "UNKNOWN"), response.pnu.newportmapping.privateport, response.pnu.newportmapping.lifetime); printf("epoch = %u\n", response.epoch); } r = closenatpmp(&natpmp); printf("closenatpmp() returned %d (%s)\n", r, r==0?"SUCCESS":"FAILED"); if(r<0) return 1; return 0; } libnatpmp-20230423/testgetgateway.c010064400017500000024000000040521442121113700163250ustar00nanardstaff/* $Id: testgetgateway.c,v 1.8 2023/04/23 10:51:11 nanard Exp $ */ /* libnatpmp Copyright (c) 2007-2011, Thomas BERNARD All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include #ifdef _WIN32 #include #else #include #include #endif #include "getgateway.h" int main(int argc, char * * argv) { (void)argc; (void)argv; struct in_addr gatewayaddr; int r; #ifdef _WIN32 uint32_t temp = 0; r = getdefaultgateway(&temp); gatewayaddr.S_un.S_addr = temp; #else r = getdefaultgateway(&(gatewayaddr.s_addr)); #endif if(r>=0) printf("default gateway : %s\n", inet_ntoa(gatewayaddr)); else fprintf(stderr, "getdefaultgateway() failed\n"); return 0; } libnatpmp-20230423/LICENSE010064400017500000024000000027671442121113700141400ustar00nanardstaffBSD 3-Clause License Copyright (c) 2007-2022, Thomas BERNARD All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. libnatpmp-20230423/wingettimeofday.c010064400017500000024000000042511442121113700164640ustar00nanardstaff/* $Id: wingettimeofday.c,v 1.7 2023/04/23 10:46:42 nanard Exp $ */ /* libnatpmp Copyright (c) 2007-2013, Thomas BERNARD All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #ifdef _WIN32 #if defined(_MSC_VER) struct timeval { long tv_sec; long tv_usec; }; #else #include #endif typedef struct _FILETIME { unsigned long dwLowDateTime; unsigned long dwHighDateTime; } FILETIME; void __stdcall GetSystemTimeAsFileTime(FILETIME*); int natpmp_gettimeofday(struct timeval* p, void* tz /* IGNORED */) { union { long long ns100; /*time since 1 Jan 1601 in 100ns units */ FILETIME ft; } _now; if(!p) return -1; GetSystemTimeAsFileTime( &(_now.ft) ); p->tv_usec =(long)((_now.ns100 / 10LL) % 1000000LL ); p->tv_sec = (long)((_now.ns100-(116444736000000000LL))/10000000LL); return 0; } #endif libnatpmp-20230423/wingettimeofday.h010064400017500000024000000033701442121113700164720ustar00nanardstaff/* $Id: wingettimeofday.h,v 1.6 2023/04/23 10:46:42 nanard Exp $ */ /* libnatpmp Copyright (c) 2007-2013, Thomas BERNARD All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #ifndef __WINGETTIMEOFDAY_H__ #define __WINGETTIMEOFDAY_H__ #ifdef _WIN32 #if defined(_MSC_VER) #include #else #include #endif int natpmp_gettimeofday(struct timeval* p, void* tz /* IGNORED */); #endif #endif libnatpmp-20230423/natpmp.def010064400017500000024000000002741103301263300150750ustar00nanardstaffLIBRARY ; libnatpmp library EXPORTS initnatpmp closenatpmp sendpublicaddressrequest sendnewportmappingrequest getnatpmprequesttimeout readnatpmpresponseorretry strnatpmperr libnatpmp-20230423/build.bat010064400017500000024000000024561442121113700147150ustar00nanardstaff@echo Compiling with MinGW @SET LIBS=-lws2_32 -liphlpapi @echo Compile getgateway gcc -c -Wall -Os -DWIN32 -DNATPMP_STATICLIB -DENABLE_STRNATPMPERR getgateway.c gcc -c -Wall -Os -DWIN32 -DNATPMP_STATICLIB -DENABLE_STRNATPMPERR testgetgateway.c gcc -o testgetgateway getgateway.o testgetgateway.o %LIBS% del testgetgateway.o @echo Compile natpmp-static: gcc -c -Wall -Os -DWIN32 -DNATPMP_STATICLIB -DENABLE_STRNATPMPERR getgateway.c gcc -c -Wall -Os -DWIN32 -DNATPMP_STATICLIB -DENABLE_STRNATPMPERR natpmp.c gcc -c -Wall -Os -DWIN32 wingettimeofday.c ar cr natpmp.a getgateway.o natpmp.o wingettimeofday.o del getgateway.o natpmp.o gcc -c -Wall -Os -DWIN32 -DNATPMP_STATICLIB -DENABLE_STRNATPMPERR natpmpc.c gcc -o natpmpc-static natpmpc.o natpmp.a %LIBS% upx --best natpmpc-static.exe del natpmpc.o @echo Create natpmp.dll: gcc -c -Wall -Os -DWIN32 -DENABLE_STRNATPMPERR -DNATPMP_EXPORTS getgateway.c gcc -c -Wall -Os -DWIN32 -DENABLE_STRNATPMPERR -DNATPMP_EXPORTS natpmp.c dllwrap -k --driver-name gcc --def natpmp.def --output-def natpmp.dll.def --implib natpmp.lib -o natpmp.dll getgateway.o natpmp.o wingettimeofday.o %LIBS% @echo Compile natpmp-shared: gcc -c -Wall -Os -DWIN32 -DENABLE_STRNATPMPERR -DNATPMP_EXPORTS natpmpc.c gcc -o natpmpc-shared natpmpc.o natpmp.lib -lws2_32 upx --best natpmpc-shared.exe del *.o libnatpmp-20230423/declspec.h010064400017500000024000000007101231650533000150520ustar00nanardstaff#ifndef DECLSPEC_H_INCLUDED #define DECLSPEC_H_INCLUDED #if defined(WIN32) && !defined(STATICLIB) /* for windows dll */ #ifdef NATPMP_EXPORTS #define LIBSPEC __declspec(dllexport) #else #define LIBSPEC __declspec(dllimport) #endif #else #if defined(__GNUC__) && __GNUC__ >= 4 /* fix dynlib for OS X 10.9.2 and Apple LLVM version 5.0 */ #define LIBSPEC __attribute__ ((visibility ("default"))) #else #define LIBSPEC #endif #endif #endif libnatpmp-20230423/libnatpmpmodule.c010064400017500000024000000167171442121113700164730ustar00nanardstaff/* $Id: libnatpmpmodule.c,v 1.8 2023/04/23 11:00:23 nanard Exp $ */ /* libnatpmp * http://miniupnp.free.fr/libnatpmp.html Copyright (c) 2007-2011, Thomas BERNARD All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include #ifdef _WIN32 #include #else #include #include #endif #define NATPMP_STATICLIB #include "structmember.h" #include "natpmp.h" /* for compatibility with Python < 2.4 */ #ifndef Py_RETURN_NONE #define Py_RETURN_NONE return Py_INCREF(Py_None), Py_None #endif #ifndef Py_RETURN_TRUE #define Py_RETURN_TRUE return Py_INCREF(Py_True), Py_True #endif #ifndef Py_RETURN_FALSE #define Py_RETURN_FALSE return Py_INCREF(Py_False), Py_False #endif typedef struct { PyObject_HEAD /* Type-specific fields go here. */ unsigned int discoverdelay; natpmp_t natpmp; } NATPMPObject; static PyMemberDef NATPMP_members[] = { {"discoverdelay", T_UINT, offsetof(NATPMPObject, discoverdelay), 0/*READWRITE*/, "value in ms used to wait for NATPMP responses" }, {NULL} }; static PyObject * NATPMPObject_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { NATPMPObject *self; self = (NATPMPObject *)type->tp_alloc(type, 0); if (self) { initnatpmp(&self->natpmp, 0, 0); } return (PyObject *)self; } static void NATPMPObject_dealloc(NATPMPObject *self) { closenatpmp(&self->natpmp); Py_TYPE(self)->tp_free((PyObject*)self); } static PyObject * NATPMP_externalipaddress(NATPMPObject *self) { int r; struct timeval timeout; fd_set fds; natpmpresp_t response; r = sendpublicaddressrequest(&self->natpmp); if (r < 0) { #ifdef ENABLE_STRNATPMPERR PyErr_SetString(PyExc_Exception, strnatpmperr(r)); #endif return NULL; } do { FD_ZERO(&fds); FD_SET(self->natpmp.s, &fds); getnatpmprequesttimeout(&self->natpmp, &timeout); select(FD_SETSIZE, &fds, NULL, NULL, &timeout); r = readnatpmpresponseorretry(&self->natpmp, &response); if (r < 0 && r != NATPMP_TRYAGAIN) { #ifdef ENABLE_STRNATPMPERR PyErr_SetString(PyExc_Exception, strnatpmperr(r)); #endif return NULL; } } while (r == NATPMP_TRYAGAIN); return Py_BuildValue("s", inet_ntoa(response.pnu.publicaddress.addr)); } static PyObject * NATPMP_domapping(natpmp_t *n, unsigned short eport, unsigned short iport, const char *protocol, unsigned int lifetime) { int proto; struct timeval timeout; fd_set fds; natpmpresp_t response; int r; if (!strncasecmp("tcp", protocol, 3)) { proto = NATPMP_PROTOCOL_TCP; } else if (!strncasecmp("udp", protocol, 3)) { proto = NATPMP_PROTOCOL_UDP; } else { PyErr_SetString(PyExc_Exception, "Unknown protocol"); return NULL; } r = sendnewportmappingrequest(n, proto, iport, eport, lifetime); if (r < 0) { #ifdef ENABLE_STRNATPMPERR PyErr_SetString(PyExc_Exception, strnatpmperr(r)); #endif return NULL; } do { FD_ZERO(&fds); FD_SET(n->s, &fds); getnatpmprequesttimeout(n, &timeout); select(FD_SETSIZE, &fds, NULL, NULL, &timeout); r = readnatpmpresponseorretry(n, &response); if (r < 0 && r != NATPMP_TRYAGAIN) { #ifdef ENABLE_STRNATPMPERR PyErr_SetString(PyExc_Exception, strnatpmperr(r)); #endif return NULL; } } while (r == NATPMP_TRYAGAIN); return Py_BuildValue("H", response.pnu.newportmapping.mappedpublicport); } /* AddPortMapping(externalPort, protocol, internalPort, lifetime) * protocol is 'UDP' or 'TCP' */ static PyObject * NATPMP_addportmapping(NATPMPObject *self, PyObject *args) { unsigned short eport; unsigned short iport; unsigned int lifetime; const char *protocol; if (!PyArg_ParseTuple(args, "HsHI", &eport, &protocol, &iport, &lifetime)) return NULL; return NATPMP_domapping(&self->natpmp, eport, iport, protocol, lifetime); } /* DeletePortMapping(externalPort, protocol, internalPort) * protocol is 'UDP' or 'TCP' */ static PyObject * NATPMP_deleteportmapping(NATPMPObject *self, PyObject *args) { unsigned short eport; unsigned short iport; const char *protocol; if (!PyArg_ParseTuple(args, "HsH", &eport, &protocol, &iport)) return NULL; return NATPMP_domapping(&self->natpmp, eport, iport, protocol, 0); } /* natpmp.NATPMP object Method Table */ static PyMethodDef NATPMP_methods[] = { {"externalipaddress", (PyCFunction)NATPMP_externalipaddress, METH_NOARGS, "return external IP address" }, {"addportmapping", (PyCFunction)NATPMP_addportmapping, METH_VARARGS, "add a port mapping" }, {"deleteportmapping", (PyCFunction)NATPMP_deleteportmapping, METH_VARARGS, "delete a port mapping" }, {NULL} /* Sentinel */ }; static PyTypeObject NATPMPType = { PyObject_HEAD_INIT(NULL) 0, /*ob_size*/ "libnatpmp.NATPMP", /*tp_name*/ sizeof(NATPMPObject), /*tp_basicsize*/ 0, /*tp_itemsize*/ (destructor)NATPMPObject_dealloc, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ 0, /*tp_compare*/ 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash */ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT, /*tp_flags*/ "NATPMP objects", /* tp_doc */ 0, /* tp_traverse */ 0, /* tp_clear */ 0, /* tp_richcompare */ 0, /* tp_weaklistoffset */ 0, /* tp_iter */ 0, /* tp_iternext */ NATPMP_methods, /* tp_methods */ NATPMP_members, /* tp_members */ 0, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ 0, /* tp_descr_set */ 0, /* tp_dictoffset */ 0, /* tp_init */ 0, /* tp_alloc */ NATPMPObject_new, /* tp_new */ }; /* module methods */ static PyMethodDef libnatpmp_methods[] = { {NULL} /* Sentinel */ }; #ifndef PyMODINIT_FUNC /* declarations for DLL import/export */ #define PyMODINIT_FUNC void #endif PyMODINIT_FUNC initlibnatpmp(void) { PyObject* m; if (PyType_Ready(&NATPMPType) < 0) return; m = Py_InitModule3("libnatpmp", libnatpmp_methods, "libnatpmp module."); Py_INCREF(&NATPMPType); PyModule_AddObject(m, "NATPMP", (PyObject *)&NATPMPType); } libnatpmp-20230423/setup.py010064400017500000024000000016601442121113700146340ustar00nanardstaff#! /usr/bin/env python # vim: tabstop=8 shiftwidth=8 expandtab # $Id: setup.py,v 1.5 2023/04/23 10:56:16 nanard Exp $ # # python script to build the libnatpmp module under unix from setuptools import setup, Extension from setuptools.command import build_ext import subprocess import os EXT = ['libnatpmp.a'] class make_then_build_ext(build_ext.build_ext): def run(self): subprocess.check_call([os.environ.get('MAKE','make')] + EXT) build_ext.build_ext.run(self) setup(name="libnatpmp", version="1.0", author='Thomas BERNARD', author_email='miniupnp@free.fr', license=open('LICENSE').read(), description='NAT-PMP library', cmdclass={'build_ext': make_then_build_ext}, ext_modules=[ Extension(name="libnatpmp", sources=["libnatpmpmodule.c"], extra_objects=EXT, define_macros=[('ENABLE_STRNATPMPERR', None)] )] ) libnatpmp-20230423/setupmingw32.py010064400017500000024000000011341365604170000160450ustar00nanardstaff#! /usr/bin/env python # $Id: setupmingw32.py,v 1.4 2020/04/06 10:20:38 nanard Exp $ # python script to build the miniupnpc module under windows # from distutils.core import setup, Extension from distutils import sysconfig sysconfig.get_config_vars()["OPT"] = '' sysconfig.get_config_vars()["CFLAGS"] = '' setup(name="libnatpmp", version="1.0", ext_modules=[ Extension(name="libnatpmp", sources=["libnatpmpmodule.c"], libraries=["ws2_32"], extra_objects=["libnatpmp.a"], define_macros=[('ENABLE_STRNATPMPERR', None)] )] ) libnatpmp-20230423/README010064400017500000024000000003671442121113700140050ustar00nanardstafflibnatpmp (c) 2007-2023 Thomas Bernard contact : miniupnp@free.fr see http://miniupnp.free.fr/libnatpmp.html or http://miniupnp.tuxfamily.org/libnatpmp.html for some documentation and code samples. github : https://github.com/miniupnp/libnatpmp libnatpmp-20230423/msvc/libnatpmp.sln010064400017500000024000000027071131314010000165650ustar00nanardstaff Microsoft Visual Studio Solution File, Format Version 10.00 # Visual C++ Express 2008 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libnatpmp", "libnatpmp.vcproj", "{D59B6527-F3DE-4D26-A08D-52F1EE989301}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "natpmpc-static", "natpmpc-static.vcproj", "{A0B49FA9-98AB-4A74-8B4C-8AB7FA36089B}" ProjectSection(ProjectDependencies) = postProject {D59B6527-F3DE-4D26-A08D-52F1EE989301} = {D59B6527-F3DE-4D26-A08D-52F1EE989301} EndProjectSection EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Win32 = Debug|Win32 Release|Win32 = Release|Win32 EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {D59B6527-F3DE-4D26-A08D-52F1EE989301}.Debug|Win32.ActiveCfg = Debug|Win32 {D59B6527-F3DE-4D26-A08D-52F1EE989301}.Debug|Win32.Build.0 = Debug|Win32 {D59B6527-F3DE-4D26-A08D-52F1EE989301}.Release|Win32.ActiveCfg = Release|Win32 {D59B6527-F3DE-4D26-A08D-52F1EE989301}.Release|Win32.Build.0 = Release|Win32 {A0B49FA9-98AB-4A74-8B4C-8AB7FA36089B}.Debug|Win32.ActiveCfg = Debug|Win32 {A0B49FA9-98AB-4A74-8B4C-8AB7FA36089B}.Debug|Win32.Build.0 = Debug|Win32 {A0B49FA9-98AB-4A74-8B4C-8AB7FA36089B}.Release|Win32.ActiveCfg = Release|Win32 {A0B49FA9-98AB-4A74-8B4C-8AB7FA36089B}.Release|Win32.Build.0 = Release|Win32 EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection EndGlobal libnatpmp-20230423/msvc/libnatpmp.vcproj010064400017500000024000000072341442121113700173100ustar00nanardstaff libnatpmp-20230423/msvc/natpmpc-static.vcproj010064400017500000024000000075711442121113700202550ustar00nanardstaff libnatpmp-20230423/natpmpc.1010064400017500000024000000006351157675575300147000ustar00nanardstaff.TH natpmpc 1 .SH NAME natpmpc \- NAT\-PMP library test client and mapping setter. .SH "SYNOPSIS" Display the public IP address: .br \fBnatpmpc\fP Add a port mapping: .br \fBnatpmpc\fP \-a [lifetime] .SH DESCRIPTION In order to remove a mapping, set it with a lifetime of 0 seconds. To remove all mappings for your machine, use 0 as private port and lifetime. libnatpmp-20230423/fr/free/miniupnp/libnatpmp/LibraryExtractor.java010064400017500000024000000214411206766546100244620ustar00nanardstaffpackage fr.free.miniupnp.libnatpmp; /** I (Leah X Schmidt) copied this code from jnaerator, because JNAerator's extractor requires you to buy into the whole JNA concept. JNAErator is Copyright (c) 2009 Olivier Chafik, All Rights Reserved JNAerator is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. JNAerator is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with JNAerator. If not, see . */ import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.URL; import java.net.URLConnection; import java.net.URLDecoder; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.util.Arrays; import java.util.HashSet; import java.util.Set; public class LibraryExtractor { private static boolean libPathSet = false; public static String getLibraryPath(String libraryName, boolean extractAllLibraries, Class cl) { try { String customPath = System.getProperty("library." + libraryName); if (customPath == null) customPath = System.getenv(libraryName.toUpperCase() + "_LIBRARY"); if (customPath != null) { File f = new File(customPath); if (!f.exists()) System.err.println("Library file '" + customPath + "' does not exist !"); else return f.getAbsolutePath(); } //ClassLoader cl = LibraryExtractor.class.getClassLoader(); String prefix = "(?i)" + (isWindows() ? "" : "lib") + libraryName + "[^A-Za-z_].*"; String libsuffix = "(?i).*\\.(so|dll|dylib|jnilib)"; //String othersuffix = "(?i).*\\.(pdb)"; URL sourceURL = null; List otherURLs = new ArrayList(); String arch = getCurrentOSAndArchString(); //System.out.println("libURL = " + libURL); List list = URLUtils.listFiles(URLUtils.getResource(cl, "libraries/" + arch)), noArchList = URLUtils.listFiles(URLUtils.getResource(cl, "libraries/noarch")); Set names = new HashSet(); for (URL url : list) { String name = getFileName(url); names.add(name); } for (URL url : noArchList) { String name = getFileName(url); if (names.add(name)) list.add(url); } for (File f : new File(".").listFiles()) if (f.isFile()) list.add(f.toURI().toURL()); for (URL url : list) { String name = getFileName(url); boolean pref = name.matches(prefix), suff = name.matches(libsuffix); if (pref && suff) sourceURL = url; else //if (suff || fileName.matches(othersuffix)) otherURLs.add(url); } List files = new ArrayList(); if (extractAllLibraries) { for (URL url : otherURLs) files.add(extract(url)); } if (System.getProperty("javawebstart.version") != null) { if (isWindows()) { //File f = new File("c:\\Windows\\" + (Platform.is64Bit() ? "SysWOW64\\" : "System32\\") + libraryName + ".dll"); File f = new File("c:\\Windows\\" + "System32\\" + libraryName + ".dll"); if (f.exists()) return f.toString(); } else if (isMac()) { File f = new File("/System/Library/Frameworks/" + libraryName + ".framework/" + libraryName); if (f.exists()) return f.toString(); } } if (sourceURL == null) return libraryName; else { File file = extract(sourceURL); files.add(file); int lastSize; do { lastSize = files.size(); for (Iterator it = files.iterator(); it.hasNext();) { File f = it.next(); if (!f.getName().matches(libsuffix)) continue; try { System.load(f.toString()); it.remove(); } catch (Throwable ex) { System.err.println("Loading " + f.getName() + " failed (" + ex + ")"); } } } while (files.size() < lastSize); return file.getCanonicalPath(); } } catch (Throwable ex) { System.err.println("ERROR: Failed to extract library " + libraryName); ex.printStackTrace(); return libraryName; } } public static final boolean isWindows() { String osName = System.getProperty("os.name"); return osName.startsWith("Windows"); } public static final boolean isMac() { String osName = System.getProperty("os.name"); return osName.startsWith("Mac") || osName.startsWith("Darwin"); } //this code is from JNA, but JNA has a fallback to some native //stuff in case this doesn't work. Since sun.arch.data.model is //defined for Sun and IBM, this should work nearly everywhere. public static final boolean is64Bit() { String model = System.getProperty("sun.arch.data.model", System.getProperty("com.ibm.vm.bitmode")); if (model != null) { return "64".equals(model); } String arch = System.getProperty("os.arch").toLowerCase(); if ("x86_64".equals(arch) || "ia64".equals(arch) || "ppc64".equals(arch) || "sparcv9".equals(arch) || "amd64".equals(arch)) { return true; } return false; } public static String getCurrentOSAndArchString() { String os = System.getProperty("os.name"), arch = System.getProperty("os.arch"); if (os.equals("Mac OS X")) { os = "darwin"; arch = "fat"; } else if (os.startsWith("Windows")) { return "win" + (is64Bit() ? "64" : "32"); } else if (os.matches("SunOS|Solaris")) os = "solaris"; return os + "-" + arch; } private static File extract(URL url) throws IOException { File localFile; if ("file".equals(url.getProtocol())) localFile = new File(URLDecoder.decode(url.getFile(), "UTF-8")); else { File f = new File(System.getProperty("user.home")); f = new File(f, ".jnaerator"); f = new File(f, "extractedLibraries"); if (!f.exists()) f.mkdirs(); if (!libPathSet) { String path = System.getProperty("java.library.path"); if (path == null) { System.setProperty("java.library.path", f.toString()); } else { System.setProperty("java.library.path", path + ":" + f); } libPathSet = true; } localFile = new File(f, new File(url.getFile()).getName()); URLConnection c = url.openConnection(); if (localFile.exists() && localFile.lastModified() > c.getLastModified()) { c.getInputStream().close(); } else { System.out.println("Extracting " + url); InputStream in = c.getInputStream(); OutputStream out = new FileOutputStream(localFile); int len; byte[] b = new byte[1024]; while ((len = in.read(b)) > 0) out.write(b, 0, len); out.close(); in.close(); } } return localFile; } private static String getFileName(URL url) { return new File(url.getFile()).getName(); } public static void main(String[] args) { System.out.println(getCurrentOSAndArchString()); } }libnatpmp-20230423/fr/free/miniupnp/libnatpmp/NatPmp.java010064400017500000024000000023041206766546100223560ustar00nanardstaffpackage fr.free.miniupnp.libnatpmp; import java.nio.ByteBuffer; public class NatPmp { private static final String JNA_LIBRARY_NAME = LibraryExtractor.getLibraryPath("jninatpmp", true, NatPmp.class); static { String s = JNA_LIBRARY_NAME; startup(); } public ByteBuffer natpmp; public NatPmp() { init(0, 0); } public NatPmp(int forcedgw) { init(1, forcedgw); } /** Cleans up the native resources used by this object. Attempting to use the object after this has been called will lead to crashes.*/ public void dispose() { free(); } protected void finalize() { if (natpmp != null) free(); } private native void init(int forcegw, int forcedgw); private native void free(); private static native void startup(); public native int sendPublicAddressRequest(); public native int sendNewPortMappingRequest(int protocol, int privateport, int publicport, int lifetime); //returns a number of milliseconds, in accordance with Java convention public native long getNatPmpRequestTimeout(); public native int readNatPmpResponseOrRetry(NatPmpResponse response); } libnatpmp-20230423/fr/free/miniupnp/libnatpmp/NatPmpResponse.java010064400017500000024000000012561206766546100241020ustar00nanardstaffpackage fr.free.miniupnp.libnatpmp; public class NatPmpResponse { public static final int TYPE_PUBLICADDRESS=0; public static final int TYPE_UDPPORTMAPPING=1; public static final int TYPE_TCPPORTMAPPING=2; /** see TYPE_* constants */ public short type; /** NAT-PMP response code */ public short resultcode; /** milliseconds since start of epoch */ public long epoch; /** only defined if type == 0*/ public int addr; /** only defined if type != 0 */ public int privateport; /** only defined if type != 0 */ public int mappedpublicport; /** only defined if type != 0 */ public long lifetime; //milliseconds }libnatpmp-20230423/fr/free/miniupnp/libnatpmp/URLUtils.java010064400017500000024000000054541206766546100226530ustar00nanardstaffpackage fr.free.miniupnp.libnatpmp; /** I (Leah X Schmidt) copied this code from jnaerator, because JNAerator's extractor requires you to buy into the whole JNA concept. JNAErator is Copyright (c) 2009 Olivier Chafik, All Rights Reserved JNAerator is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. JNAerator is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with JNAerator. If not, see . */ import java.io.File; import java.io.IOException; import java.io.InputStream; import java.net.URL; import java.util.ArrayList; import java.util.List; import java.util.jar.JarEntry; import java.util.jar.JarInputStream; public class URLUtils { public static URL getResource(Class cl, String path) throws IOException { String clp = cl.getName().replace('.', '/') + ".class"; URL clu = cl.getClassLoader().getResource(clp); String s = clu.toString(); if (s.endsWith(clp)) return new URL(s.substring(0, s.length() - clp.length()) + path); if (s.startsWith("jar:")) { String[] ss = s.split("!"); return new URL(ss[1] + "!/" + path); } return null; } public static List listFiles(URL directory) throws IOException { List ret = new ArrayList(); String s = directory.toString(); if (s.startsWith("jar:")) { String[] ss = s.substring("jar:".length()).split("!"); String path = ss[1]; URL target = new URL(ss[0]); InputStream tin = target.openStream(); try { JarInputStream jin = new JarInputStream(tin); JarEntry je; while ((je = jin.getNextJarEntry()) != null) { String p = "/" + je.getName(); if (p.startsWith(path) && p.indexOf('/', path.length() + 1) < 0) ret.add(new URL("jar:" + target + "!" + p)); } } finally { tin.close(); } } else if (s.startsWith("file:")) { File f = new File(directory.getFile()); File[] ffs = f.listFiles(); if (ffs != null) for (File ff : ffs) ret.add(ff.toURI().toURL()); } else throw new IOException("Cannot list contents of " + directory); return ret; } }libnatpmp-20230423/JavaTest.java010064400017500000024000000024611442121113700155060ustar00nanardstaff// vim: tabstop=8 shiftwidth=4 softtabstop=4 noexpandtab import java.net.InetAddress; import java.net.UnknownHostException; import java.nio.ByteBuffer; import fr.free.miniupnp.libnatpmp.NatPmp; import fr.free.miniupnp.libnatpmp.NatPmpResponse; class JavaTest { public static void main(String[] args) { NatPmp natpmp = new NatPmp(); natpmp.sendPublicAddressRequest(); NatPmpResponse response = new NatPmpResponse(); int result = -1; for(;;) { result = natpmp.readNatPmpResponseOrRetry(response); if (result == 0) break; if (result != -100) { // -100 = NATPMP_TRYAGAIN String errorString = String.format("NATPMP error %d", result); throw new RuntimeException(errorString); } try { Thread.sleep(4000); } catch (InterruptedException e) { //fallthrough } } byte[] bytes = intToByteArray(response.addr); try { InetAddress inetAddress = InetAddress.getByAddress(bytes); System.out.println("Public address is " + inetAddress); } catch (UnknownHostException e) { throw new RuntimeException(e); } } public static final byte[] intToByteArray(int value) { return new byte[] { (byte)value, (byte)(value >>> 8), (byte)(value >>> 16), (byte)(value >>> 24)}; } } libnatpmp-20230423/natpmp-jni.c010064400017500000024000000107511442121113700153440ustar00nanardstaff#ifdef __CYGWIN__ #include #define __int64 uint64_t #endif #ifdef _WIN32 #include #include #include #endif #include #include "natpmp.h" #include "fr_free_miniupnp_libnatpmp_NatPmp.h" #ifdef __cplusplus extern "C" { #endif JNIEXPORT void JNICALL Java_fr_free_miniupnp_libnatpmp_NatPmp_init (JNIEnv *env, jobject obj, jint forcegw, jint forcedgw) { natpmp_t *p = malloc (sizeof(natpmp_t)); if (p == NULL) return; initnatpmp(p, forcegw, (in_addr_t) forcedgw); jobject wrapped = (*env)->NewDirectByteBuffer(env, p, sizeof(natpmp_t)); if (wrapped == NULL) return; jclass thisClass = (*env)->GetObjectClass(env,obj); if (thisClass == NULL) return; jfieldID fid = (*env)->GetFieldID(env, thisClass, "natpmp", "Ljava/nio/ByteBuffer;"); if (fid == NULL) return; (*env)->SetObjectField(env, obj, fid, wrapped); } JNIEXPORT void JNICALL Java_fr_free_miniupnp_libnatpmp_NatPmp_free (JNIEnv *env, jobject obj) { jclass thisClass = (*env)->GetObjectClass(env,obj); if (thisClass == NULL) return; jfieldID fid = (*env)->GetFieldID(env, thisClass, "natpmp", "Ljava/nio/ByteBuffer;"); if (fid == NULL) return; jobject wrapped = (*env)->GetObjectField(env, obj, fid); if (wrapped == NULL) return; natpmp_t* natpmp = (natpmp_t*) (*env)->GetDirectBufferAddress(env, wrapped); closenatpmp(natpmp); if (natpmp == NULL) return; free(natpmp); (*env)->SetObjectField(env, obj, fid, NULL); } static natpmp_t* getNatPmp(JNIEnv* env, jobject obj) { jclass thisClass = (*env)->GetObjectClass(env,obj); if (thisClass == NULL) return NULL; jfieldID fid = (*env)->GetFieldID(env, thisClass, "natpmp", "Ljava/nio/ByteBuffer;"); if (fid == NULL) return NULL; jobject wrapped = (*env)->GetObjectField(env, obj, fid); if (wrapped == NULL) return NULL; natpmp_t* natpmp = (natpmp_t*) (*env)->GetDirectBufferAddress(env, wrapped); return natpmp; } JNIEXPORT jint JNICALL Java_fr_free_miniupnp_libnatpmp_NatPmp_sendPublicAddressRequest(JNIEnv* env, jobject obj) { natpmp_t* natpmp = getNatPmp(env, obj); if (natpmp == NULL) return -1; return sendpublicaddressrequest(natpmp); } JNIEXPORT void JNICALL Java_fr_free_miniupnp_libnatpmp_NatPmp_startup(JNIEnv* env, jclass cls) { (void)env; (void)cls; #ifdef _WIN32 WSADATA wsaData; WORD wVersionRequested = MAKEWORD(2, 2); WSAStartup(wVersionRequested, &wsaData); #endif } JNIEXPORT jint JNICALL Java_fr_free_miniupnp_libnatpmp_NatPmp_sendNewPortMappingRequest(JNIEnv* env, jobject obj, jint protocol, jint privateport, jint publicport, jint lifetime) { natpmp_t* natpmp = getNatPmp(env, obj); if (natpmp == NULL) return -1; return sendnewportmappingrequest(natpmp, protocol, privateport, publicport, lifetime); } JNIEXPORT jlong JNICALL Java_fr_free_miniupnp_libnatpmp_NatPmp_getNatPmpRequestTimeout(JNIEnv* env, jobject obj) { natpmp_t* natpmp = getNatPmp(env, obj); struct timeval timeout; getnatpmprequesttimeout(natpmp, &timeout); return ((jlong) timeout.tv_sec) * 1000 + (timeout.tv_usec / 1000); } #define SET_FIELD(prefix, name, type, longtype) { \ jfieldID fid = (*env)->GetFieldID(env, thisClass, #name, type); \ if (fid == NULL) return -1; \ (*env)->Set ## longtype ## Field(env, response, fid, resp. prefix name); \ } JNIEXPORT jint JNICALL Java_fr_free_miniupnp_libnatpmp_NatPmp_readNatPmpResponseOrRetry(JNIEnv* env, jobject obj, jobject response) { natpmp_t* natpmp = getNatPmp(env, obj); natpmpresp_t resp; int result = readnatpmpresponseorretry(natpmp, &resp); if (result != 0) { return result; } jclass thisClass = (*env)->GetObjectClass(env, response); if (thisClass == NULL) return -1; SET_FIELD(,type, "S", Short); SET_FIELD(,resultcode, "S", Short); jfieldID fid = (*env)->GetFieldID(env, thisClass, "epoch", "J"); if (fid == NULL) return -1; (*env)->SetLongField(env, response, fid, ((jlong)resp.epoch) * 1000); if (resp.type == 0) { jfieldID fid = (*env)->GetFieldID(env, thisClass, "addr", "I"); if (fid == NULL) return -1; (*env)->SetIntField(env, response, fid, resp.pnu.publicaddress.addr.s_addr); } else { SET_FIELD(pnu.newportmapping., privateport, "I", Int); SET_FIELD(pnu.newportmapping., mappedpublicport, "I", Int); jfieldID fid = (*env)->GetFieldID(env, thisClass, "lifetime", "J"); if (fid == NULL) return -1; (*env)->SetLongField(env, response, fid, ((jlong) resp.pnu.newportmapping.lifetime) * 1000 * 1000); } return result; } #ifdef __cplusplus } #endif libnatpmp-20230423/CMakeLists.txt010064400017500000024000000014351442121023300156560ustar00nanardstaffcmake_minimum_required(VERSION 2.8.12) if(POLICY CMP0048) cmake_policy(SET CMP0048 NEW) endif() project(natpmp) set (NATPMP_SOURCES natpmp.c getgateway.c ) if (WIN32) set (NATPMP_SOURCES ${NATPMP_SOURCES} wingettimeofday.c) endif (WIN32) # Library itself add_library(natpmp STATIC ${NATPMP_SOURCES}) target_include_directories(natpmp PUBLIC ${CMAKE_CURRENT_LIST_DIR}) target_compile_definitions(natpmp PRIVATE -DENABLE_STRNATPMPERR) if (WIN32) target_link_libraries(natpmp PUBLIC ws2_32 Iphlpapi) target_compile_definitions(natpmp PUBLIC -DNATPMP_STATICLIB) endif (WIN32) # Executables add_executable(natpmpc natpmpc.c) target_link_libraries(natpmpc natpmp) add_executable(testgetgateway testgetgateway.c getgateway.c) target_link_libraries(testgetgateway natpmp) libnatpmp-20230423/natpmp_declspec.h010064400017500000024000000007721442121110700164340ustar00nanardstaff#ifndef NATPMP_DECLSPEC_H_INCLUDED #define NATPMP_DECLSPEC_H_INCLUDED #if defined(_WIN32) && !defined(NATPMP_STATICLIB) /* for windows dll */ #ifdef NATPMP_EXPORTS #define NATPMP_LIBSPEC __declspec(dllexport) #else #define NATPMP_LIBSPEC __declspec(dllimport) #endif #else #if defined(__GNUC__) && __GNUC__ >= 4 /* fix dynlib for OS X 10.9.2 and Apple LLVM version 5.0 */ #define NATPMP_LIBSPEC __attribute__ ((visibility ("default"))) #else #define NATPMP_LIBSPEC #endif #endif #endif