programs/ipconfig/ipconfig.c

   1 /*
   2  * IP configuration utility
   3  *
   4  * Copyright 2008 Andrew Riedi
   5  * Copyright 2010 Andrew Nguyen
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <winsock2.h>
  23 #include <windows.h>
  24 #include <iphlpapi.h>
  25 #include <wine/unicode.h>
  26
  27 #include "ipconfig.h"
  28
  29 static int ipconfig_vprintfW(const WCHAR *msg, va_list va_args)
  30 {
  31     int wlen;
  32     DWORD count, ret;
  33     WCHAR msg_buffer[8192];
  34
  35     wlen = vsprintfW(msg_buffer, msg, va_args);
  36
  37     ret = WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), msg_buffer, wlen, &count, NULL);
  38     if (!ret)
  39     {
  40         DWORD len;
  41         char *msgA;
  42
  43         /* On Windows WriteConsoleW() fails if the output is redirected. So fall
  44          * back to WriteFile(), assuming the console encoding is still the right
  45          * one in that case.
  46          */
  47         len = WideCharToMultiByte(GetConsoleOutputCP(), 0, msg_buffer, wlen,
  48             NULL, 0, NULL, NULL);
  49         msgA = HeapAlloc(GetProcessHeap(), 0, len);
  50         if (!msgA)
  51             return 0;
  52
  53         WideCharToMultiByte(GetConsoleOutputCP(), 0, msg_buffer, wlen, msgA, len,
  54             NULL, NULL);
  55         WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), msgA, len, &count, FALSE);
  56         HeapFree(GetProcessHeap(), 0, msgA);
  57     }
  58
  59     return count;
  60 }
  61
  62 static int ipconfig_printfW(const WCHAR *msg, ...)
  63 {
  64     va_list va_args;
  65     int len;
  66
  67     va_start(va_args, msg);
  68     len = ipconfig_vprintfW(msg, va_args);
  69     va_end(va_args);
  70
  71     return len;
  72 }
  73
  74 static int ipconfig_message_printfW(int msg, ...)
  75 {
  76     va_list va_args;
  77     WCHAR msg_buffer[8192];
  78     int len;
  79
  80     LoadStringW(GetModuleHandleW(NULL), msg, msg_buffer,
  81         sizeof(msg_buffer)/sizeof(WCHAR));
  82
  83     va_start(va_args, msg);
  84     len = ipconfig_vprintfW(msg_buffer, va_args);
  85     va_end(va_args);
  86
  87     return len;
  88 }
  89
  90 static int ipconfig_message(int msg)
  91 {
  92     static const WCHAR formatW[] = {'%','s',0};
  93     WCHAR msg_buffer[8192];
  94
  95     LoadStringW(GetModuleHandleW(NULL), msg, msg_buffer,
  96         sizeof(msg_buffer)/sizeof(WCHAR));
  97
  98     return ipconfig_printfW(formatW, msg_buffer);
  99 }
 100
 101 static const WCHAR *iftype_to_string(DWORD type)
 102 {
 103     static WCHAR msg_buffer[50];
 104
 105     int msg;
 106
 107     switch (type)
 108     {
 109     case IF_TYPE_ETHERNET_CSMACD:
 110     /* The loopback adapter appears as an Ethernet device. */
 111     case IF_TYPE_SOFTWARE_LOOPBACK:
 112         msg = STRING_ETHERNET;
 113         break;
 114     default:
 115         msg = STRING_UNKNOWN;
 116     }
 117
 118     LoadStringW(GetModuleHandleW(NULL), msg, msg_buffer,
 119         sizeof(msg_buffer)/sizeof(WCHAR));
 120
 121     return msg_buffer;
 122 }
 123
 124 static void print_field(int msg, const WCHAR *value)
 125 {
 126     static const WCHAR formatW[] = {' ',' ',' ',' ','%','s',':',' ','%','s','\n',0};
 127
 128     WCHAR field[] = {'.',' ','.',' ','.',' ','.',' ','.',' ','.',' ','.',' ','.',' ','.',
 129                      ' ','.',' ','.',' ','.',' ','.',' ','.',' ','.',' ','.',' ','.',' ',0};
 130     WCHAR name_buffer[sizeof(field)/sizeof(WCHAR)];
 131
 132     LoadStringW(GetModuleHandleW(NULL), msg, name_buffer, sizeof(name_buffer)/sizeof(WCHAR));
 133     memcpy(field, name_buffer, sizeof(WCHAR) * min(strlenW(name_buffer), sizeof(field)/sizeof(WCHAR) - 1));
 134
 135     ipconfig_printfW(formatW, field, value);
 136 }
 137
 138 static void print_value(const WCHAR *value)
 139 {
 140     static const WCHAR formatW[] = {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
 141                                     ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
 142                                     ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
 143                                     ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
 144                                     '%','s','\n',0};
 145
 146     ipconfig_printfW(formatW, value);
 147 }
 148
 149 static BOOL socket_address_to_string(WCHAR *buf, DWORD len, SOCKET_ADDRESS *addr)
 150 {
 151     return WSAAddressToStringW(addr->lpSockaddr,
 152                                addr->iSockaddrLength, NULL,
 153                                buf, &len) == 0;
 154 }
 155
 156 static void print_basic_information(void)
 157 {
 158     IP_ADAPTER_ADDRESSES *adapters;
 159     ULONG out = 0;
 160
 161     if (GetAdaptersAddresses(AF_UNSPEC, GAA_FLAG_INCLUDE_ALL_GATEWAYS,
 162                              NULL, NULL, &out) == ERROR_BUFFER_OVERFLOW)
 163     {
 164         adapters = HeapAlloc(GetProcessHeap(), 0, out);
 165         if (!adapters)
 166             exit(1);
 167
 168         if (GetAdaptersAddresses(AF_UNSPEC, GAA_FLAG_INCLUDE_ALL_GATEWAYS,
 169                                  NULL, adapters, &out) == ERROR_SUCCESS)
 170         {
 171             IP_ADAPTER_ADDRESSES *p;
 172
 173             for (p = adapters; p; p = p->Next)
 174             {
 175                 static const WCHAR newlineW[] = {'\n',0};
 176                 static const WCHAR emptyW[] = {0};
 177
 178                 IP_ADAPTER_UNICAST_ADDRESS *addr;
 179                 IP_ADAPTER_GATEWAY_ADDRESS_LH *gateway;
 180                 WCHAR addr_buf[54];
 181
 182                 ipconfig_message_printfW(STRING_ADAPTER_FRIENDLY, iftype_to_string(p->IfType), p->FriendlyName);
 183                 ipconfig_printfW(newlineW);
 184                 print_field(STRING_CONN_DNS_SUFFIX, p->DnsSuffix);
 185
 186                 for (addr = p->FirstUnicastAddress; addr; addr = addr->Next)
 187                 {
 188                     if (socket_address_to_string(addr_buf, sizeof(addr_buf)/sizeof(WCHAR), &addr->Address))
 189                         print_field(STRING_IP_ADDRESS, addr_buf);
 190                     /* FIXME: Output corresponding subnet mask. */
 191                 }
 192
 193                 if (p->FirstGatewayAddress)
 194                 {
 195                     if (socket_address_to_string(addr_buf, sizeof(addr_buf)/sizeof(WCHAR), &p->FirstGatewayAddress->Address))
 196                         print_field(STRING_DEFAULT_GATEWAY, addr_buf);
 197
 198                     for (gateway = p->FirstGatewayAddress->Next; gateway; gateway = gateway->Next)
 199                     {
 200                         if (socket_address_to_string(addr_buf, sizeof(addr_buf)/sizeof(WCHAR), &gateway->Address))
 201                             print_value(addr_buf);
 202                     }
 203                 }
 204                 else
 205                     print_field(STRING_DEFAULT_GATEWAY, emptyW);
 206
 207                 ipconfig_printfW(newlineW);
 208             }
 209         }
 210
 211         HeapFree(GetProcessHeap(), 0, adapters);
 212     }
 213 }
 214
 215 static const WCHAR *nodetype_to_string(DWORD type)
 216 {
 217     static WCHAR msg_buffer[50];
 218
 219     int msg;
 220
 221     switch (type)
 222     {
 223     case BROADCAST_NODETYPE:
 224         msg = STRING_BROADCAST;
 225         break;
 226     case PEER_TO_PEER_NODETYPE:
 227         msg = STRING_PEER_TO_PEER;
 228         break;
 229     case MIXED_NODETYPE:
 230         msg = STRING_MIXED;
 231         break;
 232     case HYBRID_NODETYPE:
 233         msg = STRING_HYBRID;
 234         break;
 235     default:
 236         msg = STRING_UNKNOWN;
 237     }
 238
 239     LoadStringW(GetModuleHandleW(NULL), msg, msg_buffer,
 240         sizeof(msg_buffer)/sizeof(WCHAR));
 241
 242     return msg_buffer;
 243 }
 244
 245 static WCHAR *physaddr_to_string(WCHAR *buf, BYTE *addr, DWORD len)
 246 {
 247     static const WCHAR fmtW[] = {'%','0','2','X','-',0};
 248     static const WCHAR fmt2W[] = {'%','0','2','X',0};
 249
 250     if (!len)
 251         *buf = '\0';
 252     else
 253     {
 254         WCHAR *p = buf;
 255         DWORD i;
 256
 257         for (i = 0; i < len - 1; i++)
 258         {
 259             sprintfW(p, fmtW, addr[i]);
 260             p += 3;
 261         }
 262         sprintfW(p, fmt2W, addr[i]);
 263     }
 264
 265     return buf;
 266 }
 267
 268 static const WCHAR *boolean_to_string(int value)
 269 {
 270     static WCHAR msg_buffer[15];
 271
 272     LoadStringW(GetModuleHandleW(NULL), value ? STRING_YES : STRING_NO,
 273         msg_buffer, sizeof(msg_buffer)/sizeof(WCHAR));
 274
 275     return msg_buffer;
 276 }
 277
 278 static void print_full_information(void)
 279 {
 280     static const WCHAR newlineW[] = {'\n',0};
 281     static const WCHAR emptyW[] = {0};
 282
 283     FIXED_INFO *info;
 284     IP_ADAPTER_ADDRESSES *adapters;
 285     ULONG out = 0;
 286
 287     if (GetNetworkParams(NULL, &out) == ERROR_BUFFER_OVERFLOW)
 288     {
 289         info = HeapAlloc(GetProcessHeap(), 0, out);
 290         if (!info)
 291             exit(1);
 292
 293         if (GetNetworkParams(info, &out) == ERROR_SUCCESS)
 294         {
 295             WCHAR hostnameW[MAX_HOSTNAME_LEN + 4];
 296
 297             MultiByteToWideChar(CP_ACP, 0, info->HostName, -1, hostnameW, sizeof(hostnameW)/sizeof(hostnameW[0]));
 298             print_field(STRING_HOSTNAME, hostnameW);
 299
 300             /* FIXME: Output primary DNS suffix. */
 301
 302             print_field(STRING_NODE_TYPE, nodetype_to_string(info->NodeType));
 303             print_field(STRING_IP_ROUTING, boolean_to_string(info->EnableRouting));
 304
 305             /* FIXME: Output WINS proxy status and DNS suffix search list. */
 306
 307             ipconfig_printfW(newlineW);
 308         }
 309
 310         HeapFree(GetProcessHeap(), 0, info);
 311     }
 312
 313     if (GetAdaptersAddresses(AF_UNSPEC, GAA_FLAG_INCLUDE_ALL_GATEWAYS,
 314                              NULL, NULL, &out) == ERROR_BUFFER_OVERFLOW)
 315     {
 316         adapters = HeapAlloc(GetProcessHeap(), 0, out);
 317         if (!adapters)
 318             exit(1);
 319
 320         if (GetAdaptersAddresses(AF_UNSPEC, GAA_FLAG_INCLUDE_ALL_GATEWAYS,
 321                                  NULL, adapters, &out) == ERROR_SUCCESS)
 322         {
 323             IP_ADAPTER_ADDRESSES *p;
 324
 325             for (p = adapters; p; p = p->Next)
 326             {
 327                 IP_ADAPTER_UNICAST_ADDRESS *addr;
 328                 WCHAR physaddr_buf[3 * MAX_ADAPTER_ADDRESS_LENGTH];
 329                 IP_ADAPTER_GATEWAY_ADDRESS_LH *gateway;
 330                 WCHAR addr_buf[54];
 331
 332                 ipconfig_message_printfW(STRING_ADAPTER_FRIENDLY, iftype_to_string(p->IfType), p->FriendlyName);
 333                 ipconfig_printfW(newlineW);
 334                 print_field(STRING_CONN_DNS_SUFFIX, p->DnsSuffix);
 335                 print_field(STRING_DESCRIPTION, p->Description);
 336                 print_field(STRING_PHYS_ADDR, physaddr_to_string(physaddr_buf, p->PhysicalAddress, p->PhysicalAddressLength));
 337                 print_field(STRING_DHCP_ENABLED, boolean_to_string(p->Flags & IP_ADAPTER_DHCP_ENABLED));
 338
 339                 /* FIXME: Output autoconfiguration status. */
 340
 341                 for (addr = p->FirstUnicastAddress; addr; addr = addr->Next)
 342                 {
 343                     if (socket_address_to_string(addr_buf, sizeof(addr_buf)/sizeof(WCHAR), &addr->Address))
 344                         print_field(STRING_IP_ADDRESS, addr_buf);
 345                     /* FIXME: Output corresponding subnet mask. */
 346                 }
 347
 348                 if (p->FirstGatewayAddress)
 349                 {
 350                     if (socket_address_to_string(addr_buf, sizeof(addr_buf)/sizeof(WCHAR), &p->FirstGatewayAddress->Address))
 351                         print_field(STRING_DEFAULT_GATEWAY, addr_buf);
 352
 353                     for (gateway = p->FirstGatewayAddress->Next; gateway; gateway = gateway->Next)
 354                     {
 355                         if (socket_address_to_string(addr_buf, sizeof(addr_buf)/sizeof(WCHAR), &gateway->Address))
 356                             print_value(addr_buf);
 357                     }
 358                 }
 359                 else
 360                     print_field(STRING_DEFAULT_GATEWAY, emptyW);
 361
 362                 ipconfig_printfW(newlineW);
 363             }
 364         }
 365
 366         HeapFree(GetProcessHeap(), 0, adapters);
 367     }
 368 }
 369
 370 int wmain(int argc, WCHAR *argv[])
 371 {
 372     static const WCHAR slashHelp[] = {'/','?',0};
 373     static const WCHAR slashAll[] = {'/','a','l','l',0};
 374
 375     WSADATA data;
 376
 377     if (WSAStartup(MAKEWORD(2, 2), &data))
 378         return 1;
 379
 380     if (argc > 1)
 381     {
 382         if (!strcmpW(slashHelp, argv[1]))
 383         {
 384             ipconfig_message(STRING_USAGE);
 385             WSACleanup();
 386             return 1;
 387         }
 388         else if (!strcmpiW(slashAll, argv[1]))
 389         {
 390             if (argv[2])
 391             {
 392                 ipconfig_message(STRING_INVALID_CMDLINE);
 393                 ipconfig_message(STRING_USAGE);
 394                 WSACleanup();
 395                 return 1;
 396             }
 397
 398             print_full_information();
 399         }
 400         else
 401         {
 402             ipconfig_message(STRING_INVALID_CMDLINE);
 403             ipconfig_message(STRING_USAGE);
 404             WSACleanup();
 405             return 1;
 406         }
 407     }
 408     else
 409         print_basic_information();
 410
 411     WSACleanup();
 412     return 0;
 413 }