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 #define NONAMELESSUNION
  23
  24 #include <winsock2.h>
  25 #include <windows.h>
  26 #include <iphlpapi.h>
  27 #include <wine/unicode.h>
  28
  29 #include "ipconfig.h"
  30
  31 static int ipconfig_vprintfW(const WCHAR *msg, __ms_va_list va_args)
  32 {
  33     int wlen;
  34     DWORD count, ret;
  35     WCHAR msg_buffer[8192];
  36
  37     wlen = FormatMessageW(FORMAT_MESSAGE_FROM_STRING, msg, 0, 0, msg_buffer,
  38                           ARRAY_SIZE(msg_buffer), &va_args);
  39
  40     ret = WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), msg_buffer, wlen, &count, NULL);
  41     if (!ret)
  42     {
  43         DWORD len;
  44         char *msgA;
  45
  46         /* On Windows WriteConsoleW() fails if the output is redirected. So fall
  47          * back to WriteFile(), assuming the console encoding is still the right
  48          * one in that case.
  49          */
  50         len = WideCharToMultiByte(GetConsoleOutputCP(), 0, msg_buffer, wlen,
  51             NULL, 0, NULL, NULL);
  52         msgA = HeapAlloc(GetProcessHeap(), 0, len);
  53         if (!msgA)
  54             return 0;
  55
  56         WideCharToMultiByte(GetConsoleOutputCP(), 0, msg_buffer, wlen, msgA, len,
  57             NULL, NULL);
  58         WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), msgA, len, &count, FALSE);
  59         HeapFree(GetProcessHeap(), 0, msgA);
  60     }
  61
  62     return count;
  63 }
  64
  65 static int WINAPIV ipconfig_printfW(const WCHAR *msg, ...)
  66 {
  67     __ms_va_list va_args;
  68     int len;
  69
  70     __ms_va_start(va_args, msg);
  71     len = ipconfig_vprintfW(msg, va_args);
  72     __ms_va_end(va_args);
  73
  74     return len;
  75 }
  76
  77 static int WINAPIV ipconfig_message_printfW(int msg, ...)
  78 {
  79     __ms_va_list va_args;
  80     WCHAR msg_buffer[8192];
  81     int len;
  82
  83     LoadStringW(GetModuleHandleW(NULL), msg, msg_buffer, ARRAY_SIZE(msg_buffer));
  84
  85     __ms_va_start(va_args, msg);
  86     len = ipconfig_vprintfW(msg_buffer, va_args);
  87     __ms_va_end(va_args);
  88
  89     return len;
  90 }
  91
  92 static int ipconfig_message(int msg)
  93 {
  94     static const WCHAR formatW[] = {'%','1',0};
  95     WCHAR msg_buffer[8192];
  96
  97     LoadStringW(GetModuleHandleW(NULL), msg, msg_buffer, ARRAY_SIZE(msg_buffer));
  98
  99     return ipconfig_printfW(formatW, msg_buffer);
 100 }
 101
 102 static const WCHAR *iftype_to_string(DWORD type)
 103 {
 104     static WCHAR msg_buffer[50];
 105
 106     int msg;
 107
 108     switch (type)
 109     {
 110     case IF_TYPE_ETHERNET_CSMACD:
 111     /* The loopback adapter appears as an Ethernet device. */
 112     case IF_TYPE_SOFTWARE_LOOPBACK:
 113         msg = STRING_ETHERNET;
 114         break;
 115     default:
 116         msg = STRING_UNKNOWN;
 117     }
 118
 119     LoadStringW(GetModuleHandleW(NULL), msg, msg_buffer, ARRAY_SIZE(msg_buffer));
 120
 121     return msg_buffer;
 122 }
 123
 124 static void print_field(int msg, const WCHAR *value)
 125 {
 126     static const WCHAR formatW[] = {' ',' ',' ',' ','%','1',':',' ','%','2','\n',0};
 127
 128     WCHAR field[] = {'.',' ','.',' ','.',' ','.',' ','.',' ','.',' ','.',' ','.',' ','.',
 129                      ' ','.',' ','.',' ','.',' ','.',' ','.',' ','.',' ','.',' ','.',' ',0};
 130     WCHAR name_buffer[ARRAY_SIZE(field)];
 131
 132     LoadStringW(GetModuleHandleW(NULL), msg, name_buffer, ARRAY_SIZE(name_buffer));
 133     memcpy(field, name_buffer, sizeof(WCHAR) * min(strlenW(name_buffer), ARRAY_SIZE(field) - 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                                     '%','1','\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 (addr->Address.lpSockaddr->sa_family == AF_INET &&
 189                         socket_address_to_string(addr_buf, ARRAY_SIZE(addr_buf), &addr->Address))
 190                         print_field(STRING_IP_ADDRESS, addr_buf);
 191                     else if (addr->Address.lpSockaddr->sa_family == AF_INET6 &&
 192                              socket_address_to_string(addr_buf, ARRAY_SIZE(addr_buf), &addr->Address))
 193                         print_field(STRING_IP6_ADDRESS, addr_buf);
 194                     /* FIXME: Output corresponding subnet mask. */
 195                 }
 196
 197                 if (p->FirstGatewayAddress)
 198                 {
 199                     if (socket_address_to_string(addr_buf, ARRAY_SIZE(addr_buf), &p->FirstGatewayAddress->Address))
 200                         print_field(STRING_DEFAULT_GATEWAY, addr_buf);
 201
 202                     for (gateway = p->FirstGatewayAddress->Next; gateway; gateway = gateway->Next)
 203                     {
 204                         if (socket_address_to_string(addr_buf, ARRAY_SIZE(addr_buf), &gateway->Address))
 205                             print_value(addr_buf);
 206                     }
 207                 }
 208                 else
 209                     print_field(STRING_DEFAULT_GATEWAY, emptyW);
 210
 211                 ipconfig_printfW(newlineW);
 212             }
 213         }
 214
 215         HeapFree(GetProcessHeap(), 0, adapters);
 216     }
 217 }
 218
 219 static const WCHAR *nodetype_to_string(DWORD type)
 220 {
 221     static WCHAR msg_buffer[50];
 222
 223     int msg;
 224
 225     switch (type)
 226     {
 227     case BROADCAST_NODETYPE:
 228         msg = STRING_BROADCAST;
 229         break;
 230     case PEER_TO_PEER_NODETYPE:
 231         msg = STRING_PEER_TO_PEER;
 232         break;
 233     case MIXED_NODETYPE:
 234         msg = STRING_MIXED;
 235         break;
 236     case HYBRID_NODETYPE:
 237         msg = STRING_HYBRID;
 238         break;
 239     default:
 240         msg = STRING_UNKNOWN;
 241     }
 242
 243     LoadStringW(GetModuleHandleW(NULL), msg, msg_buffer, ARRAY_SIZE(msg_buffer));
 244
 245     return msg_buffer;
 246 }
 247
 248 static WCHAR *physaddr_to_string(WCHAR *buf, BYTE *addr, DWORD len)
 249 {
 250     static const WCHAR fmtW[] = {'%','0','2','X','-',0};
 251     static const WCHAR fmt2W[] = {'%','0','2','X',0};
 252
 253     if (!len)
 254         *buf = '\0';
 255     else
 256     {
 257         WCHAR *p = buf;
 258         DWORD i;
 259
 260         for (i = 0; i < len - 1; i++)
 261         {
 262             sprintfW(p, fmtW, addr[i]);
 263             p += 3;
 264         }
 265         sprintfW(p, fmt2W, addr[i]);
 266     }
 267
 268     return buf;
 269 }
 270
 271 static const WCHAR *boolean_to_string(int value)
 272 {
 273     static WCHAR msg_buffer[15];
 274
 275     LoadStringW(GetModuleHandleW(NULL), value ? STRING_YES : STRING_NO,
 276         msg_buffer, ARRAY_SIZE(msg_buffer));
 277
 278     return msg_buffer;
 279 }
 280
 281 static void print_full_information(void)
 282 {
 283     static const WCHAR newlineW[] = {'\n',0};
 284     static const WCHAR emptyW[] = {0};
 285
 286     FIXED_INFO *info;
 287     IP_ADAPTER_ADDRESSES *adapters;
 288     ULONG out = 0;
 289
 290     if (GetNetworkParams(NULL, &out) == ERROR_BUFFER_OVERFLOW)
 291     {
 292         info = HeapAlloc(GetProcessHeap(), 0, out);
 293         if (!info)
 294             exit(1);
 295
 296         if (GetNetworkParams(info, &out) == ERROR_SUCCESS)
 297         {
 298             WCHAR hostnameW[MAX_HOSTNAME_LEN + 4];
 299
 300             MultiByteToWideChar(CP_ACP, 0, info->HostName, -1, hostnameW, ARRAY_SIZE(hostnameW));
 301             print_field(STRING_HOSTNAME, hostnameW);
 302
 303             /* FIXME: Output primary DNS suffix. */
 304
 305             print_field(STRING_NODE_TYPE, nodetype_to_string(info->NodeType));
 306             print_field(STRING_IP_ROUTING, boolean_to_string(info->EnableRouting));
 307
 308             /* FIXME: Output WINS proxy status and DNS suffix search list. */
 309
 310             ipconfig_printfW(newlineW);
 311         }
 312
 313         HeapFree(GetProcessHeap(), 0, info);
 314     }
 315
 316     if (GetAdaptersAddresses(AF_UNSPEC, GAA_FLAG_INCLUDE_ALL_GATEWAYS,
 317                              NULL, NULL, &out) == ERROR_BUFFER_OVERFLOW)
 318     {
 319         adapters = HeapAlloc(GetProcessHeap(), 0, out);
 320         if (!adapters)
 321             exit(1);
 322
 323         if (GetAdaptersAddresses(AF_UNSPEC, GAA_FLAG_INCLUDE_ALL_GATEWAYS,
 324                                  NULL, adapters, &out) == ERROR_SUCCESS)
 325         {
 326             IP_ADAPTER_ADDRESSES *p;
 327
 328             for (p = adapters; p; p = p->Next)
 329             {
 330                 IP_ADAPTER_UNICAST_ADDRESS *addr;
 331                 WCHAR physaddr_buf[3 * MAX_ADAPTER_ADDRESS_LENGTH];
 332                 IP_ADAPTER_GATEWAY_ADDRESS_LH *gateway;
 333                 WCHAR addr_buf[54];
 334
 335                 ipconfig_message_printfW(STRING_ADAPTER_FRIENDLY, iftype_to_string(p->IfType), p->FriendlyName);
 336                 ipconfig_printfW(newlineW);
 337                 print_field(STRING_CONN_DNS_SUFFIX, p->DnsSuffix);
 338                 print_field(STRING_DESCRIPTION, p->Description);
 339                 print_field(STRING_PHYS_ADDR, physaddr_to_string(physaddr_buf, p->PhysicalAddress, p->PhysicalAddressLength));
 340                 print_field(STRING_DHCP_ENABLED, boolean_to_string(p->u1.Flags & IP_ADAPTER_DHCP_ENABLED));
 341
 342                 /* FIXME: Output autoconfiguration status. */
 343
 344                 for (addr = p->FirstUnicastAddress; addr; addr = addr->Next)
 345                 {
 346                     if (addr->Address.lpSockaddr->sa_family == AF_INET &&
 347                         socket_address_to_string(addr_buf, ARRAY_SIZE(addr_buf), &addr->Address))
 348                         print_field(STRING_IP_ADDRESS, addr_buf);
 349                     else if (addr->Address.lpSockaddr->sa_family == AF_INET6 &&
 350                              socket_address_to_string(addr_buf, ARRAY_SIZE(addr_buf), &addr->Address))
 351                         print_field(STRING_IP6_ADDRESS, addr_buf);
 352                     /* FIXME: Output corresponding subnet mask. */
 353                 }
 354
 355                 if (p->FirstGatewayAddress)
 356                 {
 357                     if (socket_address_to_string(addr_buf, ARRAY_SIZE(addr_buf), &p->FirstGatewayAddress->Address))
 358                         print_field(STRING_DEFAULT_GATEWAY, addr_buf);
 359
 360                     for (gateway = p->FirstGatewayAddress->Next; gateway; gateway = gateway->Next)
 361                     {
 362                         if (socket_address_to_string(addr_buf, ARRAY_SIZE(addr_buf), &gateway->Address))
 363                             print_value(addr_buf);
 364                     }
 365                 }
 366                 else
 367                     print_field(STRING_DEFAULT_GATEWAY, emptyW);
 368
 369                 ipconfig_printfW(newlineW);
 370             }
 371         }
 372
 373         HeapFree(GetProcessHeap(), 0, adapters);
 374     }
 375 }
 376
 377 int wmain(int argc, WCHAR *argv[])
 378 {
 379     static const WCHAR slashHelp[] = {'/','?',0};
 380     static const WCHAR slashAll[] = {'/','a','l','l',0};
 381
 382     WSADATA data;
 383
 384     if (WSAStartup(MAKEWORD(2, 2), &data))
 385         return 1;
 386
 387     if (argc > 1)
 388     {
 389         if (!strcmpW(slashHelp, argv[1]))
 390         {
 391             ipconfig_message(STRING_USAGE);
 392             WSACleanup();
 393             return 1;
 394         }
 395         else if (!strcmpiW(slashAll, argv[1]))
 396         {
 397             if (argv[2])
 398             {
 399                 ipconfig_message(STRING_INVALID_CMDLINE);
 400                 ipconfig_message(STRING_USAGE);
 401                 WSACleanup();
 402                 return 1;
 403             }
 404
 405             print_full_information();
 406         }
 407         else
 408         {
 409             ipconfig_message(STRING_INVALID_CMDLINE);
 410             ipconfig_message(STRING_USAGE);
 411             WSACleanup();
 412             return 1;
 413         }
 414     }
 415     else
 416         print_basic_information();
 417
 418     WSACleanup();
 419     return 0;
 420 }