source: branches/1.4x/third-party/libnatpmp/getgateway.c @ 7487

Last change on this file since 7487 was 6967, checked in by charles, 14 years ago

update to miniupnpc-1.2 and libnatpmp-20081009

File size: 12.4 KB
Line 
1/* $Id: getgateway.c,v 1.12 2008/10/06 10:04:16 nanard Exp $ */
2/* libnatpmp
3 * Copyright (c) 2007-2008, Thomas BERNARD <miniupnp@free.fr>
4 *
5 * Permission to use, copy, modify, and/or distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
16#include <stdio.h>
17#include <ctype.h>
18#ifndef WIN32
19#include <netinet/in.h>
20#endif
21#include <sys/param.h>
22/* There is no portable method to get the default route gateway.
23 * So below are three differents functions implementing this.
24 * Parsing /proc/net/route is for linux.
25 * sysctl is the way to access such informations on BSD systems.
26 * Many systems should provide route information through raw PF_ROUTE
27 * sockets. */
28#ifdef __linux__
29#define USE_PROC_NET_ROUTE
30#undef USE_SOCKET_ROUTE
31#undef USE_SYSCTL_NET_ROUTE
32#endif
33
34#ifdef BSD
35#undef USE_PROC_NET_ROUTE
36#define USE_SOCKET_ROUTE
37#undef USE_SYSCTL_NET_ROUTE
38#endif
39
40#ifdef __APPLE__
41#undef USE_PROC_NET_ROUTE
42#undef USE_SOCKET_ROUTE
43#define USE_SYSCTL_NET_ROUTE
44#endif
45
46#if (defined(sun) && defined(__SVR4))
47#undef USE_PROC_NET_ROUTE
48#define USE_SOCKET_ROUTE
49#undef USE_SYSCTL_NET_ROUTE
50#endif
51
52#ifdef WIN32
53#undef USE_PROC_NET_ROUTE
54#undef USE_SOCKET_ROUTE
55#undef USE_SYSCTL_NET_ROUTE
56#define USE_WIN32_CODE
57#endif
58
59#ifdef USE_SYSCTL_NET_ROUTE
60#include <stdlib.h>
61#include <sys/sysctl.h>
62#include <sys/socket.h>
63#include <net/route.h>
64#endif
65#ifdef USE_SOCKET_ROUTE
66#include <unistd.h>
67#include <string.h>
68#include <sys/socket.h>
69#include <net/if.h>
70#include <net/route.h>
71#endif
72#ifdef WIN32
73#include <unknwn.h>
74#include <winreg.h>
75#define MAX_KEY_LENGTH 255
76#define MAX_VALUE_LENGTH 16383
77#endif
78#include "getgateway.h"
79
80#ifndef WIN32
81#define SUCCESS (0)
82#define FAILED  (-1)
83#endif
84
85#ifdef USE_PROC_NET_ROUTE
86int getdefaultgateway(in_addr_t * addr)
87{
88        long d, g;
89        char buf[256];
90        int line = 0;
91        FILE * f;
92        char * p;
93        f = fopen("/proc/net/route", "r");
94        if(!f)
95                return FAILED;
96        while(fgets(buf, sizeof(buf), f)) {
97                if(line > 0) {
98                        p = buf;
99                        while(*p && !isspace(*p))
100                                p++;
101                        while(*p && isspace(*p))
102                                p++;
103                        if(sscanf(p, "%lx%lx", &d, &g)==2) {
104                                if(d == 0) { /* default */
105                                        *addr = g;
106                                        fclose(f);
107                                        return SUCCESS;
108                                }
109                        }
110                }
111                line++;
112        }
113        /* default route not found ! */
114        if(f)
115                fclose(f);
116        return FAILED;
117}
118#endif /* #ifdef USE_PROC_NET_ROUTE */
119
120
121#ifdef USE_SYSCTL_NET_ROUTE
122
123#define ROUNDUP(a) \
124        ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
125
126int getdefaultgateway(in_addr_t * addr)
127{
128#if 0
129        /* net.route.0.inet.dump.0.0 ? */
130        int mib[] = {CTL_NET, PF_ROUTE, 0, AF_INET,
131                     NET_RT_DUMP, 0, 0/*tableid*/};
132#endif
133        /* net.route.0.inet.flags.gateway */
134        int mib[] = {CTL_NET, PF_ROUTE, 0, AF_INET,
135                     NET_RT_FLAGS, RTF_GATEWAY};
136        size_t l;
137        char * buf, * p;
138        struct rt_msghdr * rt;
139        struct sockaddr * sa;
140        struct sockaddr * sa_tab[RTAX_MAX];
141        int i;
142        int r = FAILED;
143        if(sysctl(mib, sizeof(mib)/sizeof(int), 0, &l, 0, 0) < 0) {
144                return FAILED;
145        }
146        if(l>0) {
147                buf = malloc(l);
148                if(sysctl(mib, sizeof(mib)/sizeof(int), buf, &l, 0, 0) < 0) {
149                        free(buf);
150                        return FAILED;
151                }
152                for(p=buf; p<buf+l; p+=rt->rtm_msglen) {
153                        rt = (struct rt_msghdr *)p;
154                        sa = (struct sockaddr *)(rt + 1);
155                        for(i=0; i<RTAX_MAX; i++) {
156                                if(rt->rtm_addrs & (1 << i)) {
157                                        sa_tab[i] = sa;
158                                        sa = (struct sockaddr *)((char *)sa + ROUNDUP(sa->sa_len));
159                                } else {
160                                        sa_tab[i] = NULL;
161                                }
162                        }
163                        if( ((rt->rtm_addrs & (RTA_DST|RTA_GATEWAY)) == (RTA_DST|RTA_GATEWAY))
164              && sa_tab[RTAX_DST]->sa_family == AF_INET
165              && sa_tab[RTAX_GATEWAY]->sa_family == AF_INET) {
166                                if(((struct sockaddr_in *)sa_tab[RTAX_DST])->sin_addr.s_addr == 0) {
167                                        *addr = ((struct sockaddr_in *)(sa_tab[RTAX_GATEWAY]))->sin_addr.s_addr;
168                                        r = SUCCESS;
169                                }
170                        }
171                }
172                free(buf);
173        }
174        return r;
175}
176#endif /* #ifdef USE_SYSCTL_NET_ROUTE */
177
178
179#ifdef USE_SOCKET_ROUTE
180/* Thanks to Darren Kenny for this code */
181#define NEXTADDR(w, u) \
182        if (rtm_addrs & (w)) {\
183            l = sizeof(struct sockaddr); memmove(cp, &(u), l); cp += l;\
184        }
185
186#define rtm m_rtmsg.m_rtm
187
188struct {
189  struct rt_msghdr m_rtm;
190  char       m_space[512];
191} m_rtmsg;
192
193int getdefaultgateway(in_addr_t *addr)
194{
195  int s, seq, l, rtm_addrs, i;
196  pid_t pid;
197  struct sockaddr so_dst, so_mask;
198  char *cp = m_rtmsg.m_space; 
199  struct sockaddr *gate = NULL, *sa;
200  struct rt_msghdr *msg_hdr;
201
202  pid = getpid();
203  seq = 0;
204  rtm_addrs = RTA_DST | RTA_NETMASK;
205
206  memset(&so_dst, 0, sizeof(so_dst));
207  memset(&so_mask, 0, sizeof(so_mask));
208  memset(&rtm, 0, sizeof(struct rt_msghdr));
209
210  rtm.rtm_type = RTM_GET;
211  rtm.rtm_flags = RTF_UP | RTF_GATEWAY;
212  rtm.rtm_version = RTM_VERSION;
213  rtm.rtm_seq = ++seq;
214  rtm.rtm_addrs = rtm_addrs; 
215
216  so_dst.sa_family = AF_INET;
217  so_mask.sa_family = AF_INET;
218
219  NEXTADDR(RTA_DST, so_dst);
220  NEXTADDR(RTA_NETMASK, so_mask);
221
222  rtm.rtm_msglen = l = cp - (char *)&m_rtmsg;
223
224  s = socket(PF_ROUTE, SOCK_RAW, 0);
225
226  if (write(s, (char *)&m_rtmsg, l) < 0) {
227      close(s);
228      return FAILED;
229  }
230
231  do {
232    l = read(s, (char *)&m_rtmsg, sizeof(m_rtmsg));
233  } while (l > 0 && (rtm.rtm_seq != seq || rtm.rtm_pid != pid));
234                       
235  close(s);
236
237  msg_hdr = &rtm;
238
239  cp = ((char *)(msg_hdr + 1));
240  if (msg_hdr->rtm_addrs) {
241    for (i = 1; i; i <<= 1)
242      if (i & msg_hdr->rtm_addrs) {
243        sa = (struct sockaddr *)cp;
244        if (i == RTA_GATEWAY )
245          gate = sa;
246
247        cp += sizeof(struct sockaddr);
248      }
249  } else {
250      return FAILED;
251  }
252
253
254  if (gate != NULL ) {
255      *addr = ((struct sockaddr_in *)gate)->sin_addr.s_addr;
256      return SUCCESS;
257  } else {
258      return FAILED;
259  }
260}
261#endif /* #ifdef USE_SOCKET_ROUTE */
262
263#ifdef USE_WIN32_CODE
264int getdefaultgateway(in_addr_t * addr)
265{
266        HKEY networkCardsKey;
267        HKEY networkCardKey;
268        HKEY interfacesKey;
269        HKEY interfaceKey;
270        DWORD i = 0;
271        DWORD numSubKeys = 0;
272        TCHAR keyName[MAX_KEY_LENGTH];
273        DWORD keyNameLength = MAX_KEY_LENGTH;
274        TCHAR keyValue[MAX_VALUE_LENGTH];
275        DWORD keyValueLength = MAX_VALUE_LENGTH;
276        DWORD keyValueType = REG_SZ;
277        TCHAR gatewayValue[MAX_VALUE_LENGTH];
278        DWORD gatewayValueLength = MAX_VALUE_LENGTH;
279        DWORD gatewayValueType = REG_MULTI_SZ;
280        int done = 0;
281       
282        char networkCardsPath[] = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\NetworkCards";
283        char interfacesPath[] = "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces";
284       
285        // The windows registry lists its primary network devices in the following location:
286        // HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\NetworkCards
287        //
288        // Each network device has its own subfolder, named with an index, with various properties:
289        // -NetworkCards
290        //   -5
291        //     -Description = Broadcom 802.11n Network Adapter
292        //     -ServiceName = {E35A72F8-5065-4097-8DFE-C7790774EE4D}
293        //   -8
294        //     -Description = Marvell Yukon 88E8058 PCI-E Gigabit Ethernet Controller
295        //     -ServiceName = {86226414-5545-4335-A9D1-5BD7120119AD}
296        //
297        // The above service name is the name of a subfolder within:
298        // HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\Interfaces
299        //
300        // There may be more subfolders in this interfaces path than listed in the network cards path above:
301        // -Interfaces
302        //   -{3a539854-6a70-11db-887c-806e6f6e6963}
303        //     -DhcpIPAddress = 0.0.0.0
304        //     -[more]
305        //   -{E35A72F8-5065-4097-8DFE-C7790774EE4D}
306        //     -DhcpIPAddress = 10.0.1.4
307        //     -DhcpDefaultGateway = 10.0.1.1
308        //     -[more]
309        //   -{86226414-5545-4335-A9D1-5BD7120119AD}
310        //     -DhcpIpAddress = 10.0.1.5
311        //     -DhcpDefaultGateay = 10.0.1.1
312        //     -[more]
313        //
314        // In order to extract this information, we enumerate each network card, and extract the ServiceName value.
315        // This is then used to open the interface subfolder, and attempt to extract a DhcpDefaultGateway value.
316        // Once one is found, we're done.
317        //
318        // It may be possible to simply enumerate the interface folders until we find one with a DhcpDefaultGateway value.
319        // However, the technique used is the technique most cited on the web, and we assume it to be more correct.
320       
321        if(ERROR_SUCCESS != RegOpenKeyEx(HKEY_LOCAL_MACHINE, // Open registry key or predifined key
322                                         networkCardsPath,   // Name of registry subkey to open
323                                         0,                  // Reserved - must be zero
324                                         KEY_READ,           // Mask - desired access rights
325                                         &networkCardsKey))  // Pointer to output key
326        {
327                // Unable to open network cards keys
328                return -1;
329        }
330       
331        if(ERROR_SUCCESS != RegOpenKeyEx(HKEY_LOCAL_MACHINE, // Open registry key or predefined key
332                                         interfacesPath,     // Name of registry subkey to open
333                                         0,                  // Reserved - must be zero
334                                         KEY_READ,           // Mask - desired access rights
335                                         &interfacesKey))    // Pointer to output key
336        {
337                // Unable to open interfaces key
338                RegCloseKey(networkCardsKey);
339                return -1;
340        }
341       
342        // Figure out how many subfolders are within the NetworkCards folder
343        RegQueryInfoKey(networkCardsKey, NULL, NULL, NULL, &numSubKeys, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
344       
345        //printf( "Number of subkeys: %u\n", (unsigned int)numSubKeys);
346       
347        // Enumrate through each subfolder within the NetworkCards folder
348        for(i = 0; i < numSubKeys && !done; i++)
349        {
350                keyNameLength = MAX_KEY_LENGTH;
351                if(ERROR_SUCCESS == RegEnumKeyEx(networkCardsKey, // Open registry key
352                                                 i,               // Index of subkey to retrieve
353                                                 keyName,         // Buffer that receives the name of the subkey
354                                                 &keyNameLength,  // Variable that receives the size of the above buffer
355                                                 NULL,            // Reserved - must be NULL
356                                                 NULL,            // Buffer that receives the class string
357                                                 NULL,            // Variable that receives the size of the above buffer
358                                                 NULL))           // Variable that receives the last write time of subkey
359                {
360                        if(RegOpenKeyEx(networkCardsKey,  keyName, 0, KEY_READ, &networkCardKey) == ERROR_SUCCESS)
361                        {
362                                keyValueLength = MAX_VALUE_LENGTH;
363                                if(ERROR_SUCCESS == RegQueryValueEx(networkCardKey,   // Open registry key
364                                                                    "ServiceName",    // Name of key to query
365                                                                    NULL,             // Reserved - must be NULL
366                                                                    &keyValueType,    // Receives value type
367                                                                    keyValue,         // Receives value
368                                                                    &keyValueLength)) // Receives value length in bytes
369                                {
370                                        //printf("keyValue: %s\n", keyValue);
371                                       
372                                        if(RegOpenKeyEx(interfacesKey, keyValue, 0, KEY_READ, &interfaceKey) == ERROR_SUCCESS)
373                                        {
374                                                gatewayValueLength = MAX_VALUE_LENGTH;
375                                                if(ERROR_SUCCESS == RegQueryValueEx(interfaceKey,         // Open registry key
376                                                                                    "DhcpDefaultGateway", // Name of key to query
377                                                                                    NULL,                 // Reserved - must be NULL
378                                                                                    &gatewayValueType,    // Receives value type
379                                                                                    gatewayValue,         // Receives value
380                                                                                    &gatewayValueLength)) // Receives value length in bytes
381                                                {
382                                                        // Check to make sure it's a string
383                                                        if(gatewayValueType == REG_MULTI_SZ || gatewayValueType == REG_SZ)
384                                                        {
385                                                                //printf("gatewayValue: %s\n", gatewayValue);
386                                                                done = 1;
387                                                        }
388                                                }
389                                                RegCloseKey(interfaceKey);
390                                        }
391                                }
392                                RegCloseKey(networkCardKey);
393                        }
394                }
395        }
396       
397        RegCloseKey(interfacesKey);
398        RegCloseKey(networkCardsKey);
399       
400        if(done)
401        {
402                *addr = inet_addr(gatewayValue);
403                return 0;
404        }
405       
406        return -1;
407}
408#endif /* #ifdef USE_WIN32_CODE */
409
Note: See TracBrowser for help on using the repository browser.