2 * An implementation of key value pair (KVP) functionality for Linux.
5 * Copyright (C) 2010, Novell, Inc.
6 * Author : K. Y. Srinivasan <ksrinivasan@novell.com>
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License version 2 as published
10 * by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
15 * NON INFRINGEMENT. See the GNU General Public License for more
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
25 #include <sys/types.h>
26 #include <sys/socket.h>
28 #include <sys/utsname.h>
29 #include <linux/types.h>
36 #include <arpa/inet.h>
37 #include <linux/connector.h>
38 #include <linux/hyperv.h>
39 #include <linux/netlink.h>
49 * KVP protocol: The user mode component first registers with the
50 * the kernel component. Subsequently, the kernel component requests, data
51 * for the specified keys. In response to this message the user mode component
52 * fills in the value corresponding to the specified key. We overload the
53 * sequence field in the cn_msg header to define our KVP message types.
55 * We use this infrastructure for also supporting queries from user mode
56 * application for state that may be maintained in the KVP kernel component.
62 FullyQualifiedDomainName
= 0,
63 IntegrationServicesVersion
, /*This key is serviced in the kernel*/
82 static char kvp_send_buffer
[4096];
83 static char kvp_recv_buffer
[4096 * 2];
84 static struct sockaddr_nl addr
;
85 static int in_hand_shake
= 1;
87 static char *os_name
= "";
88 static char *os_major
= "";
89 static char *os_minor
= "";
90 static char *processor_arch
;
91 static char *os_build
;
92 static char *os_version
;
93 static char *lic_version
= "Unknown version";
94 static struct utsname uts_buf
;
97 * The location of the interface configuration file.
100 #define KVP_CONFIG_LOC "/var/lib/hyperv"
102 #define MAX_FILE_NAME 100
103 #define ENTRIES_PER_BLOCK 50
106 #define SOL_NETLINK 270
110 char key
[HV_KVP_EXCHANGE_MAX_KEY_SIZE
];
111 char value
[HV_KVP_EXCHANGE_MAX_VALUE_SIZE
];
114 struct kvp_file_state
{
117 struct kvp_record
*records
;
119 char fname
[MAX_FILE_NAME
];
122 static struct kvp_file_state kvp_file_info
[KVP_POOL_COUNT
];
124 static void kvp_acquire_lock(int pool
)
126 struct flock fl
= {F_WRLCK
, SEEK_SET
, 0, 0, 0};
129 if (fcntl(kvp_file_info
[pool
].fd
, F_SETLKW
, &fl
) == -1) {
130 syslog(LOG_ERR
, "Failed to acquire the lock pool: %d", pool
);
135 static void kvp_release_lock(int pool
)
137 struct flock fl
= {F_UNLCK
, SEEK_SET
, 0, 0, 0};
140 if (fcntl(kvp_file_info
[pool
].fd
, F_SETLK
, &fl
) == -1) {
142 syslog(LOG_ERR
, "Failed to release the lock pool: %d", pool
);
147 static void kvp_update_file(int pool
)
150 size_t bytes_written
;
153 * We are going to write our in-memory registry out to
154 * disk; acquire the lock first.
156 kvp_acquire_lock(pool
);
158 filep
= fopen(kvp_file_info
[pool
].fname
, "we");
160 kvp_release_lock(pool
);
161 syslog(LOG_ERR
, "Failed to open file, pool: %d", pool
);
165 bytes_written
= fwrite(kvp_file_info
[pool
].records
,
166 sizeof(struct kvp_record
),
167 kvp_file_info
[pool
].num_records
, filep
);
169 if (ferror(filep
) || fclose(filep
)) {
170 kvp_release_lock(pool
);
171 syslog(LOG_ERR
, "Failed to write file, pool: %d", pool
);
175 kvp_release_lock(pool
);
178 static void kvp_update_mem_state(int pool
)
181 size_t records_read
= 0;
182 struct kvp_record
*record
= kvp_file_info
[pool
].records
;
183 struct kvp_record
*readp
;
184 int num_blocks
= kvp_file_info
[pool
].num_blocks
;
185 int alloc_unit
= sizeof(struct kvp_record
) * ENTRIES_PER_BLOCK
;
187 kvp_acquire_lock(pool
);
189 filep
= fopen(kvp_file_info
[pool
].fname
, "re");
191 kvp_release_lock(pool
);
192 syslog(LOG_ERR
, "Failed to open file, pool: %d", pool
);
196 readp
= &record
[records_read
];
197 records_read
+= fread(readp
, sizeof(struct kvp_record
),
198 ENTRIES_PER_BLOCK
* num_blocks
,
202 syslog(LOG_ERR
, "Failed to read file, pool: %d", pool
);
208 * We have more data to read.
211 record
= realloc(record
, alloc_unit
* num_blocks
);
213 if (record
== NULL
) {
214 syslog(LOG_ERR
, "malloc failed");
222 kvp_file_info
[pool
].num_blocks
= num_blocks
;
223 kvp_file_info
[pool
].records
= record
;
224 kvp_file_info
[pool
].num_records
= records_read
;
227 kvp_release_lock(pool
);
229 static int kvp_file_init(void)
235 struct kvp_record
*record
;
236 struct kvp_record
*readp
;
239 int alloc_unit
= sizeof(struct kvp_record
) * ENTRIES_PER_BLOCK
;
241 if (access(KVP_CONFIG_LOC
, F_OK
)) {
242 if (mkdir(KVP_CONFIG_LOC
, 0755 /* rwxr-xr-x */)) {
243 syslog(LOG_ERR
, " Failed to create %s", KVP_CONFIG_LOC
);
248 for (i
= 0; i
< KVP_POOL_COUNT
; i
++) {
249 fname
= kvp_file_info
[i
].fname
;
252 sprintf(fname
, "%s/.kvp_pool_%d", KVP_CONFIG_LOC
, i
);
253 fd
= open(fname
, O_RDWR
| O_CREAT
| O_CLOEXEC
, 0644 /* rw-r--r-- */);
259 filep
= fopen(fname
, "re");
263 record
= malloc(alloc_unit
* num_blocks
);
264 if (record
== NULL
) {
269 readp
= &record
[records_read
];
270 records_read
+= fread(readp
, sizeof(struct kvp_record
),
275 syslog(LOG_ERR
, "Failed to read file, pool: %d",
282 * We have more data to read.
285 record
= realloc(record
, alloc_unit
*
287 if (record
== NULL
) {
295 kvp_file_info
[i
].fd
= fd
;
296 kvp_file_info
[i
].num_blocks
= num_blocks
;
297 kvp_file_info
[i
].records
= record
;
298 kvp_file_info
[i
].num_records
= records_read
;
306 static int kvp_key_delete(int pool
, const char *key
, int key_size
)
311 struct kvp_record
*record
;
314 * First update the in-memory state.
316 kvp_update_mem_state(pool
);
318 num_records
= kvp_file_info
[pool
].num_records
;
319 record
= kvp_file_info
[pool
].records
;
321 for (i
= 0; i
< num_records
; i
++) {
322 if (memcmp(key
, record
[i
].key
, key_size
))
325 * Found a match; just move the remaining
328 if (i
== num_records
) {
329 kvp_file_info
[pool
].num_records
--;
330 kvp_update_file(pool
);
336 for (; k
< num_records
; k
++) {
337 strcpy(record
[j
].key
, record
[k
].key
);
338 strcpy(record
[j
].value
, record
[k
].value
);
342 kvp_file_info
[pool
].num_records
--;
343 kvp_update_file(pool
);
349 static int kvp_key_add_or_modify(int pool
, const char *key
, int key_size
, const char *value
,
354 struct kvp_record
*record
;
357 if ((key_size
> HV_KVP_EXCHANGE_MAX_KEY_SIZE
) ||
358 (value_size
> HV_KVP_EXCHANGE_MAX_VALUE_SIZE
))
362 * First update the in-memory state.
364 kvp_update_mem_state(pool
);
366 num_records
= kvp_file_info
[pool
].num_records
;
367 record
= kvp_file_info
[pool
].records
;
368 num_blocks
= kvp_file_info
[pool
].num_blocks
;
370 for (i
= 0; i
< num_records
; i
++) {
371 if (memcmp(key
, record
[i
].key
, key_size
))
374 * Found a match; just update the value -
375 * this is the modify case.
377 memcpy(record
[i
].value
, value
, value_size
);
378 kvp_update_file(pool
);
383 * Need to add a new entry;
385 if (num_records
== (ENTRIES_PER_BLOCK
* num_blocks
)) {
386 /* Need to allocate a larger array for reg entries. */
387 record
= realloc(record
, sizeof(struct kvp_record
) *
388 ENTRIES_PER_BLOCK
* (num_blocks
+ 1));
392 kvp_file_info
[pool
].num_blocks
++;
395 memcpy(record
[i
].value
, value
, value_size
);
396 memcpy(record
[i
].key
, key
, key_size
);
397 kvp_file_info
[pool
].records
= record
;
398 kvp_file_info
[pool
].num_records
++;
399 kvp_update_file(pool
);
403 static int kvp_get_value(int pool
, const char *key
, int key_size
, char *value
,
408 struct kvp_record
*record
;
410 if ((key_size
> HV_KVP_EXCHANGE_MAX_KEY_SIZE
) ||
411 (value_size
> HV_KVP_EXCHANGE_MAX_VALUE_SIZE
))
415 * First update the in-memory state.
417 kvp_update_mem_state(pool
);
419 num_records
= kvp_file_info
[pool
].num_records
;
420 record
= kvp_file_info
[pool
].records
;
422 for (i
= 0; i
< num_records
; i
++) {
423 if (memcmp(key
, record
[i
].key
, key_size
))
426 * Found a match; just copy the value out.
428 memcpy(value
, record
[i
].value
, value_size
);
435 static int kvp_pool_enumerate(int pool
, int index
, char *key
, int key_size
,
436 char *value
, int value_size
)
438 struct kvp_record
*record
;
441 * First update our in-memory database.
443 kvp_update_mem_state(pool
);
444 record
= kvp_file_info
[pool
].records
;
446 if (index
>= kvp_file_info
[pool
].num_records
) {
450 memcpy(key
, record
[index
].key
, key_size
);
451 memcpy(value
, record
[index
].value
, value_size
);
456 void kvp_get_os_info(void)
462 os_version
= uts_buf
.release
;
463 os_build
= strdup(uts_buf
.release
);
465 os_name
= uts_buf
.sysname
;
466 processor_arch
= uts_buf
.machine
;
469 * The current windows host (win7) expects the build
470 * string to be of the form: x.y.z
471 * Strip additional information we may have.
473 p
= strchr(os_version
, '-');
478 * Parse the /etc/os-release file if present:
479 * http://www.freedesktop.org/software/systemd/man/os-release.html
481 file
= fopen("/etc/os-release", "r");
483 while (fgets(buf
, sizeof(buf
), file
)) {
486 /* Ignore comments */
490 /* Split into name=value */
491 p
= strchr(buf
, '=');
496 /* Remove quotes and newline; un-escape */
505 } else if (*p
== '\'' || *p
== '"' ||
514 if (!strcmp(buf
, "NAME")) {
519 } else if (!strcmp(buf
, "VERSION_ID")) {
530 /* Fallback for older RH/SUSE releases */
531 file
= fopen("/etc/SuSE-release", "r");
533 goto kvp_osinfo_found
;
534 file
= fopen("/etc/redhat-release", "r");
536 goto kvp_osinfo_found
;
539 * We don't have information about the os.
544 /* up to three lines */
545 p
= fgets(buf
, sizeof(buf
), file
);
547 p
= strchr(buf
, '\n');
556 p
= fgets(buf
, sizeof(buf
), file
);
558 p
= strchr(buf
, '\n');
567 p
= fgets(buf
, sizeof(buf
), file
);
569 p
= strchr(buf
, '\n');
587 * Retrieve an interface name corresponding to the specified guid.
588 * If there is a match, the function returns a pointer
589 * to the interface name and if not, a NULL is returned.
590 * If a match is found, the caller is responsible for
591 * freeing the memory.
594 static char *kvp_get_if_name(char *guid
)
597 struct dirent
*entry
;
600 char *if_name
= NULL
;
602 char *kvp_net_dir
= "/sys/class/net/";
605 dir
= opendir(kvp_net_dir
);
609 snprintf(dev_id
, sizeof(dev_id
), "%s", kvp_net_dir
);
610 q
= dev_id
+ strlen(kvp_net_dir
);
612 while ((entry
= readdir(dir
)) != NULL
) {
614 * Set the state for the next pass.
617 strcat(dev_id
, entry
->d_name
);
618 strcat(dev_id
, "/device/device_id");
620 file
= fopen(dev_id
, "r");
624 p
= fgets(buf
, sizeof(buf
), file
);
630 if (!strcmp(p
, guid
)) {
632 * Found the guid match; return the interface
633 * name. The caller will free the memory.
635 if_name
= strdup(entry
->d_name
);
648 * Retrieve the MAC address given the interface name.
651 static char *kvp_if_name_to_mac(char *if_name
)
658 char *mac_addr
= NULL
;
660 snprintf(addr_file
, sizeof(addr_file
), "%s%s%s", "/sys/class/net/",
661 if_name
, "/address");
663 file
= fopen(addr_file
, "r");
667 p
= fgets(buf
, sizeof(buf
), file
);
672 for (i
= 0; i
< strlen(p
); i
++)
673 p
[i
] = toupper(p
[i
]);
674 mac_addr
= strdup(p
);
683 * Retrieve the interface name given tha MAC address.
686 static char *kvp_mac_to_if_name(char *mac
)
689 struct dirent
*entry
;
692 char *if_name
= NULL
;
694 char *kvp_net_dir
= "/sys/class/net/";
698 dir
= opendir(kvp_net_dir
);
702 snprintf(dev_id
, sizeof(dev_id
), kvp_net_dir
);
703 q
= dev_id
+ strlen(kvp_net_dir
);
705 while ((entry
= readdir(dir
)) != NULL
) {
707 * Set the state for the next pass.
711 strcat(dev_id
, entry
->d_name
);
712 strcat(dev_id
, "/address");
714 file
= fopen(dev_id
, "r");
718 p
= fgets(buf
, sizeof(buf
), file
);
724 for (i
= 0; i
< strlen(p
); i
++)
725 p
[i
] = toupper(p
[i
]);
727 if (!strcmp(p
, mac
)) {
729 * Found the MAC match; return the interface
730 * name. The caller will free the memory.
732 if_name
= strdup(entry
->d_name
);
745 static void kvp_process_ipconfig_file(char *cmd
,
746 char *config_buf
, int len
,
747 int element_size
, int offset
)
755 * First execute the command.
757 file
= popen(cmd
, "r");
762 memset(config_buf
, 0, len
);
763 while ((p
= fgets(buf
, sizeof(buf
), file
)) != NULL
) {
764 if ((len
- strlen(config_buf
)) < (element_size
+ 1))
769 strcat(config_buf
, p
);
770 strcat(config_buf
, ";");
775 static void kvp_get_ipconfig_info(char *if_name
,
776 struct hv_kvp_ipaddr_value
*buffer
)
784 * Get the address of default gateway (ipv4).
786 sprintf(cmd
, "%s %s", "ip route show dev", if_name
);
787 strcat(cmd
, " | awk '/default/ {print $3 }'");
790 * Execute the command to gather gateway info.
792 kvp_process_ipconfig_file(cmd
, (char *)buffer
->gate_way
,
793 (MAX_GATEWAY_SIZE
* 2), INET_ADDRSTRLEN
, 0);
796 * Get the address of default gateway (ipv6).
798 sprintf(cmd
, "%s %s", "ip -f inet6 route show dev", if_name
);
799 strcat(cmd
, " | awk '/default/ {print $3 }'");
802 * Execute the command to gather gateway info (ipv6).
804 kvp_process_ipconfig_file(cmd
, (char *)buffer
->gate_way
,
805 (MAX_GATEWAY_SIZE
* 2), INET6_ADDRSTRLEN
, 1);
809 * Gather the DNS state.
810 * Since there is no standard way to get this information
811 * across various distributions of interest; we just invoke
812 * an external script that needs to be ported across distros
815 * Following is the expected format of the information from the script:
817 * ipaddr1 (nameserver1)
818 * ipaddr2 (nameserver2)
823 sprintf(cmd
, "%s", "hv_get_dns_info");
826 * Execute the command to gather DNS info.
828 kvp_process_ipconfig_file(cmd
, (char *)buffer
->dns_addr
,
829 (MAX_IP_ADDR_SIZE
* 2), INET_ADDRSTRLEN
, 0);
832 * Gather the DHCP state.
833 * We will gather this state by invoking an external script.
834 * The parameter to the script is the interface name.
835 * Here is the expected output:
837 * Enabled: DHCP enabled.
840 sprintf(cmd
, "%s %s", "hv_get_dhcp_info", if_name
);
842 file
= popen(cmd
, "r");
846 p
= fgets(dhcp_info
, sizeof(dhcp_info
), file
);
852 if (!strncmp(p
, "Enabled", 7))
853 buffer
->dhcp_enabled
= 1;
855 buffer
->dhcp_enabled
= 0;
861 static unsigned int hweight32(unsigned int *w
)
863 unsigned int res
= *w
- ((*w
>> 1) & 0x55555555);
864 res
= (res
& 0x33333333) + ((res
>> 2) & 0x33333333);
865 res
= (res
+ (res
>> 4)) & 0x0F0F0F0F;
866 res
= res
+ (res
>> 8);
867 return (res
+ (res
>> 16)) & 0x000000FF;
870 static int kvp_process_ip_address(void *addrp
,
871 int family
, char *buffer
,
872 int length
, int *offset
)
874 struct sockaddr_in
*addr
;
875 struct sockaddr_in6
*addr6
;
880 if (family
== AF_INET
) {
881 addr
= (struct sockaddr_in
*)addrp
;
882 str
= inet_ntop(family
, &addr
->sin_addr
, tmp
, 50);
883 addr_length
= INET_ADDRSTRLEN
;
885 addr6
= (struct sockaddr_in6
*)addrp
;
886 str
= inet_ntop(family
, &addr6
->sin6_addr
.s6_addr
, tmp
, 50);
887 addr_length
= INET6_ADDRSTRLEN
;
890 if ((length
- *offset
) < addr_length
+ 2)
893 strcpy(buffer
, "inet_ntop failed\n");
903 *offset
+= strlen(str
) + 1;
909 kvp_get_ip_info(int family
, char *if_name
, int op
,
910 void *out_buffer
, int length
)
912 struct ifaddrs
*ifap
;
913 struct ifaddrs
*curp
;
918 struct hv_kvp_ipaddr_value
*ip_buffer
;
919 char cidr_mask
[5]; /* /xyz */
924 struct sockaddr_in6
*addr6
;
926 if (op
== KVP_OP_ENUMERATE
) {
929 ip_buffer
= out_buffer
;
930 buffer
= (char *)ip_buffer
->ip_addr
;
931 ip_buffer
->addr_family
= 0;
934 * On entry into this function, the buffer is capable of holding the
938 if (getifaddrs(&ifap
)) {
939 strcpy(buffer
, "getifaddrs failed\n");
944 while (curp
!= NULL
) {
945 if (curp
->ifa_addr
== NULL
) {
946 curp
= curp
->ifa_next
;
950 if ((if_name
!= NULL
) &&
951 (strncmp(curp
->ifa_name
, if_name
, strlen(if_name
)))) {
953 * We want info about a specific interface;
956 curp
= curp
->ifa_next
;
961 * We only support two address families: AF_INET and AF_INET6.
962 * If a family value of 0 is specified, we collect both
963 * supported address families; if not we gather info on
964 * the specified address family.
966 if ((((family
!= 0) &&
967 (curp
->ifa_addr
->sa_family
!= family
))) ||
968 (curp
->ifa_flags
& IFF_LOOPBACK
)) {
969 curp
= curp
->ifa_next
;
972 if ((curp
->ifa_addr
->sa_family
!= AF_INET
) &&
973 (curp
->ifa_addr
->sa_family
!= AF_INET6
)) {
974 curp
= curp
->ifa_next
;
978 if (op
== KVP_OP_GET_IP_INFO
) {
980 * Gather info other than the IP address.
981 * IP address info will be gathered later.
983 if (curp
->ifa_addr
->sa_family
== AF_INET
) {
984 ip_buffer
->addr_family
|= ADDR_FAMILY_IPV4
;
988 error
= kvp_process_ip_address(
998 ip_buffer
->addr_family
|= ADDR_FAMILY_IPV6
;
1001 * Get subnet info in CIDR format.
1004 sn_str
= (char *)ip_buffer
->sub_net
;
1005 addr6
= (struct sockaddr_in6
*)
1007 w
= addr6
->sin6_addr
.s6_addr32
;
1009 for (i
= 0; i
< 4; i
++)
1010 weight
+= hweight32(&w
[i
]);
1012 sprintf(cidr_mask
, "/%d", weight
);
1013 if ((length
- sn_offset
) <
1014 (strlen(cidr_mask
) + 1))
1018 strcpy(sn_str
, cidr_mask
);
1020 strcat(sn_str
, cidr_mask
);
1021 strcat((char *)ip_buffer
->sub_net
, ";");
1022 sn_offset
+= strlen(sn_str
) + 1;
1026 * Collect other ip related configuration info.
1029 kvp_get_ipconfig_info(if_name
, ip_buffer
);
1033 error
= kvp_process_ip_address(curp
->ifa_addr
,
1034 curp
->ifa_addr
->sa_family
,
1040 curp
= curp
->ifa_next
;
1049 static int expand_ipv6(char *addr
, int type
)
1052 struct in6_addr v6_addr
;
1054 ret
= inet_pton(AF_INET6
, addr
, &v6_addr
);
1057 if (type
== NETMASK
)
1062 sprintf(addr
, "%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:"
1063 "%02x%02x:%02x%02x:%02x%02x",
1064 (int)v6_addr
.s6_addr
[0], (int)v6_addr
.s6_addr
[1],
1065 (int)v6_addr
.s6_addr
[2], (int)v6_addr
.s6_addr
[3],
1066 (int)v6_addr
.s6_addr
[4], (int)v6_addr
.s6_addr
[5],
1067 (int)v6_addr
.s6_addr
[6], (int)v6_addr
.s6_addr
[7],
1068 (int)v6_addr
.s6_addr
[8], (int)v6_addr
.s6_addr
[9],
1069 (int)v6_addr
.s6_addr
[10], (int)v6_addr
.s6_addr
[11],
1070 (int)v6_addr
.s6_addr
[12], (int)v6_addr
.s6_addr
[13],
1071 (int)v6_addr
.s6_addr
[14], (int)v6_addr
.s6_addr
[15]);
1077 static int is_ipv4(char *addr
)
1080 struct in_addr ipv4_addr
;
1082 ret
= inet_pton(AF_INET
, addr
, &ipv4_addr
);
1089 static int parse_ip_val_buffer(char *in_buf
, int *offset
,
1090 char *out_buf
, int out_len
)
1096 * in_buf has sequence of characters that are seperated by
1097 * the character ';'. The last sequence does not have the
1098 * terminating ";" character.
1100 start
= in_buf
+ *offset
;
1102 x
= strchr(start
, ';');
1106 x
= start
+ strlen(start
);
1108 if (strlen(start
) != 0) {
1111 * Get rid of leading spaces.
1113 while (start
[i
] == ' ')
1116 if ((x
- start
) <= out_len
) {
1117 strcpy(out_buf
, (start
+ i
));
1118 *offset
+= (x
- start
) + 1;
1125 static int kvp_write_file(FILE *f
, char *s1
, char *s2
, char *s3
)
1129 ret
= fprintf(f
, "%s%s%s%s\n", s1
, s2
, "=", s3
);
1138 static int process_ip_string(FILE *f
, char *ip_string
, int type
)
1141 char addr
[INET6_ADDRSTRLEN
];
1148 memset(addr
, 0, sizeof(addr
));
1150 while (parse_ip_val_buffer(ip_string
, &offset
, addr
,
1151 (MAX_IP_ADDR_SIZE
* 2))) {
1154 if (is_ipv4(addr
)) {
1157 snprintf(str
, sizeof(str
), "%s", "IPADDR");
1160 snprintf(str
, sizeof(str
), "%s", "NETMASK");
1163 snprintf(str
, sizeof(str
), "%s", "GATEWAY");
1166 snprintf(str
, sizeof(str
), "%s", "DNS");
1171 snprintf(sub_str
, sizeof(sub_str
), "%d", ++i
);
1172 } else if (type
== GATEWAY
&& i
== 0) {
1175 snprintf(sub_str
, sizeof(sub_str
), "%d", i
++);
1179 } else if (expand_ipv6(addr
, type
)) {
1182 snprintf(str
, sizeof(str
), "%s", "IPV6ADDR");
1185 snprintf(str
, sizeof(str
), "%s", "IPV6NETMASK");
1188 snprintf(str
, sizeof(str
), "%s",
1192 snprintf(str
, sizeof(str
), "%s", "DNS");
1197 snprintf(sub_str
, sizeof(sub_str
), "%d", ++i
);
1198 } else if (j
== 0) {
1201 snprintf(sub_str
, sizeof(sub_str
), "_%d", j
++);
1204 return HV_INVALIDARG
;
1207 error
= kvp_write_file(f
, str
, sub_str
, addr
);
1210 memset(addr
, 0, sizeof(addr
));
1216 static int kvp_set_ip_info(char *if_name
, struct hv_kvp_ipaddr_value
*new_val
)
1225 * Set the configuration for the specified interface with
1226 * the information provided. Since there is no standard
1227 * way to configure an interface, we will have an external
1228 * script that does the job of configuring the interface and
1229 * flushing the configuration.
1231 * The parameters passed to this external script are:
1232 * 1. A configuration file that has the specified configuration.
1234 * We will embed the name of the interface in the configuration
1235 * file: ifcfg-ethx (where ethx is the interface name).
1237 * The information provided here may be more than what is needed
1238 * in a given distro to configure the interface and so are free
1239 * ignore information that may not be relevant.
1241 * Here is the format of the ip configuration file:
1244 * DEVICE=interface name
1245 * BOOTPROTO=<protocol> (where <protocol> is "dhcp" if DHCP is configured
1246 * or "none" if no boot-time protocol should be used)
1250 * IPADDRx=ipaddry (where y = x + 1)
1253 * NETMASKx=netmasky (where y = x + 1)
1256 * GATEWAYx=ipaddry (where y = x + 1)
1258 * DNSx=ipaddrx (where first DNS address is tagged as DNS1 etc)
1260 * IPV6 addresses will be tagged as IPV6ADDR, IPV6 gateway will be
1261 * tagged as IPV6_DEFAULTGW and IPV6 NETMASK will be tagged as
1264 * The host can specify multiple ipv4 and ipv6 addresses to be
1265 * configured for the interface. Furthermore, the configuration
1266 * needs to be persistent. A subsequent GET call on the interface
1267 * is expected to return the configuration that is set via the SET
1271 snprintf(if_file
, sizeof(if_file
), "%s%s%s", KVP_CONFIG_LOC
,
1272 "/ifcfg-", if_name
);
1274 file
= fopen(if_file
, "w");
1277 syslog(LOG_ERR
, "Failed to open config file");
1282 * First write out the MAC address.
1285 mac_addr
= kvp_if_name_to_mac(if_name
);
1286 if (mac_addr
== NULL
) {
1291 error
= kvp_write_file(file
, "HWADDR", "", mac_addr
);
1295 error
= kvp_write_file(file
, "DEVICE", "", if_name
);
1299 if (new_val
->dhcp_enabled
) {
1300 error
= kvp_write_file(file
, "BOOTPROTO", "", "dhcp");
1310 error
= kvp_write_file(file
, "BOOTPROTO", "", "none");
1316 * Write the configuration for ipaddress, netmask, gateway and
1320 error
= process_ip_string(file
, (char *)new_val
->ip_addr
, IPADDR
);
1324 error
= process_ip_string(file
, (char *)new_val
->sub_net
, NETMASK
);
1328 error
= process_ip_string(file
, (char *)new_val
->gate_way
, GATEWAY
);
1332 error
= process_ip_string(file
, (char *)new_val
->dns_addr
, DNS
);
1341 * Now that we have populated the configuration file,
1342 * invoke the external script to do its magic.
1345 snprintf(cmd
, sizeof(cmd
), "%s %s", "hv_set_ifconfig", if_file
);
1350 syslog(LOG_ERR
, "Failed to write config file");
1358 kvp_get_domain_name(char *buffer
, int length
)
1360 struct addrinfo hints
, *info
;
1363 gethostname(buffer
, length
);
1364 memset(&hints
, 0, sizeof(hints
));
1365 hints
.ai_family
= AF_INET
; /*Get only ipv4 addrinfo. */
1366 hints
.ai_socktype
= SOCK_STREAM
;
1367 hints
.ai_flags
= AI_CANONNAME
;
1369 error
= getaddrinfo(buffer
, NULL
, &hints
, &info
);
1371 strcpy(buffer
, "getaddrinfo failed\n");
1374 strcpy(buffer
, info
->ai_canonname
);
1380 netlink_send(int fd
, struct cn_msg
*msg
)
1382 struct nlmsghdr
*nlh
;
1384 struct msghdr message
;
1386 struct iovec iov
[2];
1388 size
= NLMSG_SPACE(sizeof(struct cn_msg
) + msg
->len
);
1390 nlh
= (struct nlmsghdr
*)buffer
;
1392 nlh
->nlmsg_pid
= getpid();
1393 nlh
->nlmsg_type
= NLMSG_DONE
;
1394 nlh
->nlmsg_len
= NLMSG_LENGTH(size
- sizeof(*nlh
));
1395 nlh
->nlmsg_flags
= 0;
1397 iov
[0].iov_base
= nlh
;
1398 iov
[0].iov_len
= sizeof(*nlh
);
1400 iov
[1].iov_base
= msg
;
1401 iov
[1].iov_len
= size
;
1403 memset(&message
, 0, sizeof(message
));
1404 message
.msg_name
= &addr
;
1405 message
.msg_namelen
= sizeof(addr
);
1406 message
.msg_iov
= iov
;
1407 message
.msg_iovlen
= 2;
1409 return sendmsg(fd
, &message
, 0);
1414 int fd
, len
, nl_group
;
1416 struct cn_msg
*message
;
1418 struct nlmsghdr
*incoming_msg
;
1419 struct cn_msg
*incoming_cn_msg
;
1420 struct hv_kvp_msg
*hv_msg
;
1427 struct hv_kvp_ipaddr_value
*kvp_ip_val
;
1430 openlog("KVP", 0, LOG_USER
);
1431 syslog(LOG_INFO
, "KVP starting; pid is:%d", getpid());
1433 * Retrieve OS release information.
1437 if (kvp_file_init()) {
1438 syslog(LOG_ERR
, "Failed to initialize the pools");
1442 fd
= socket(AF_NETLINK
, SOCK_DGRAM
, NETLINK_CONNECTOR
);
1444 syslog(LOG_ERR
, "netlink socket creation failed; error:%d", fd
);
1447 addr
.nl_family
= AF_NETLINK
;
1453 error
= bind(fd
, (struct sockaddr
*)&addr
, sizeof(addr
));
1455 syslog(LOG_ERR
, "bind failed; error:%d", error
);
1459 nl_group
= CN_KVP_IDX
;
1460 setsockopt(fd
, SOL_NETLINK
, NETLINK_ADD_MEMBERSHIP
, &nl_group
, sizeof(nl_group
));
1462 * Register ourselves with the kernel.
1464 message
= (struct cn_msg
*)kvp_send_buffer
;
1465 message
->id
.idx
= CN_KVP_IDX
;
1466 message
->id
.val
= CN_KVP_VAL
;
1468 hv_msg
= (struct hv_kvp_msg
*)message
->data
;
1469 hv_msg
->kvp_hdr
.operation
= KVP_OP_REGISTER1
;
1471 message
->len
= sizeof(struct hv_kvp_msg
);
1473 len
= netlink_send(fd
, message
);
1475 syslog(LOG_ERR
, "netlink_send failed; error:%d", len
);
1483 struct sockaddr
*addr_p
= (struct sockaddr
*) &addr
;
1484 socklen_t addr_l
= sizeof(addr
);
1485 pfd
.events
= POLLIN
;
1489 len
= recvfrom(fd
, kvp_recv_buffer
, sizeof(kvp_recv_buffer
), 0,
1493 syslog(LOG_ERR
, "recvfrom failed; pid:%u error:%d %s",
1494 addr
.nl_pid
, errno
, strerror(errno
));
1500 syslog(LOG_WARNING
, "Received packet from untrusted pid:%u",
1505 incoming_msg
= (struct nlmsghdr
*)kvp_recv_buffer
;
1507 if (incoming_msg
->nlmsg_type
!= NLMSG_DONE
)
1510 incoming_cn_msg
= (struct cn_msg
*)NLMSG_DATA(incoming_msg
);
1511 hv_msg
= (struct hv_kvp_msg
*)incoming_cn_msg
->data
;
1514 * We will use the KVP header information to pass back
1515 * the error from this daemon. So, first copy the state
1516 * and set the error code to success.
1518 op
= hv_msg
->kvp_hdr
.operation
;
1519 pool
= hv_msg
->kvp_hdr
.pool
;
1520 hv_msg
->error
= HV_S_OK
;
1522 if ((in_hand_shake
) && (op
== KVP_OP_REGISTER1
)) {
1524 * Driver is registering with us; stash away the version
1528 p
= (char *)hv_msg
->body
.kvp_register
.version
;
1529 lic_version
= malloc(strlen(p
) + 1);
1531 strcpy(lic_version
, p
);
1532 syslog(LOG_INFO
, "KVP LIC Version: %s",
1535 syslog(LOG_ERR
, "malloc failed");
1541 case KVP_OP_GET_IP_INFO
:
1542 kvp_ip_val
= &hv_msg
->body
.kvp_ip_val
;
1544 kvp_mac_to_if_name((char *)kvp_ip_val
->adapter_id
);
1546 if (if_name
== NULL
) {
1548 * We could not map the mac address to an
1549 * interface name; return error.
1551 hv_msg
->error
= HV_E_FAIL
;
1554 error
= kvp_get_ip_info(
1555 0, if_name
, KVP_OP_GET_IP_INFO
,
1557 (MAX_IP_ADDR_SIZE
* 2));
1560 hv_msg
->error
= error
;
1565 case KVP_OP_SET_IP_INFO
:
1566 kvp_ip_val
= &hv_msg
->body
.kvp_ip_val
;
1567 if_name
= kvp_get_if_name(
1568 (char *)kvp_ip_val
->adapter_id
);
1569 if (if_name
== NULL
) {
1571 * We could not map the guid to an
1572 * interface name; return error.
1574 hv_msg
->error
= HV_GUID_NOTFOUND
;
1577 error
= kvp_set_ip_info(if_name
, kvp_ip_val
);
1579 hv_msg
->error
= error
;
1585 if (kvp_key_add_or_modify(pool
,
1586 hv_msg
->body
.kvp_set
.data
.key
,
1587 hv_msg
->body
.kvp_set
.data
.key_size
,
1588 hv_msg
->body
.kvp_set
.data
.value
,
1589 hv_msg
->body
.kvp_set
.data
.value_size
))
1590 hv_msg
->error
= HV_S_CONT
;
1594 if (kvp_get_value(pool
,
1595 hv_msg
->body
.kvp_set
.data
.key
,
1596 hv_msg
->body
.kvp_set
.data
.key_size
,
1597 hv_msg
->body
.kvp_set
.data
.value
,
1598 hv_msg
->body
.kvp_set
.data
.value_size
))
1599 hv_msg
->error
= HV_S_CONT
;
1603 if (kvp_key_delete(pool
,
1604 hv_msg
->body
.kvp_delete
.key
,
1605 hv_msg
->body
.kvp_delete
.key_size
))
1606 hv_msg
->error
= HV_S_CONT
;
1613 if (op
!= KVP_OP_ENUMERATE
)
1617 * If the pool is KVP_POOL_AUTO, dynamically generate
1618 * both the key and the value; if not read from the
1621 if (pool
!= KVP_POOL_AUTO
) {
1622 if (kvp_pool_enumerate(pool
,
1623 hv_msg
->body
.kvp_enum_data
.index
,
1624 hv_msg
->body
.kvp_enum_data
.data
.key
,
1625 HV_KVP_EXCHANGE_MAX_KEY_SIZE
,
1626 hv_msg
->body
.kvp_enum_data
.data
.value
,
1627 HV_KVP_EXCHANGE_MAX_VALUE_SIZE
))
1628 hv_msg
->error
= HV_S_CONT
;
1632 hv_msg
= (struct hv_kvp_msg
*)incoming_cn_msg
->data
;
1633 key_name
= (char *)hv_msg
->body
.kvp_enum_data
.data
.key
;
1634 key_value
= (char *)hv_msg
->body
.kvp_enum_data
.data
.value
;
1636 switch (hv_msg
->body
.kvp_enum_data
.index
) {
1637 case FullyQualifiedDomainName
:
1638 kvp_get_domain_name(key_value
,
1639 HV_KVP_EXCHANGE_MAX_VALUE_SIZE
);
1640 strcpy(key_name
, "FullyQualifiedDomainName");
1642 case IntegrationServicesVersion
:
1643 strcpy(key_name
, "IntegrationServicesVersion");
1644 strcpy(key_value
, lic_version
);
1646 case NetworkAddressIPv4
:
1647 kvp_get_ip_info(AF_INET
, NULL
, KVP_OP_ENUMERATE
,
1648 key_value
, HV_KVP_EXCHANGE_MAX_VALUE_SIZE
);
1649 strcpy(key_name
, "NetworkAddressIPv4");
1651 case NetworkAddressIPv6
:
1652 kvp_get_ip_info(AF_INET6
, NULL
, KVP_OP_ENUMERATE
,
1653 key_value
, HV_KVP_EXCHANGE_MAX_VALUE_SIZE
);
1654 strcpy(key_name
, "NetworkAddressIPv6");
1657 strcpy(key_value
, os_build
);
1658 strcpy(key_name
, "OSBuildNumber");
1661 strcpy(key_value
, os_name
);
1662 strcpy(key_name
, "OSName");
1664 case OSMajorVersion
:
1665 strcpy(key_value
, os_major
);
1666 strcpy(key_name
, "OSMajorVersion");
1668 case OSMinorVersion
:
1669 strcpy(key_value
, os_minor
);
1670 strcpy(key_name
, "OSMinorVersion");
1673 strcpy(key_value
, os_version
);
1674 strcpy(key_name
, "OSVersion");
1676 case ProcessorArchitecture
:
1677 strcpy(key_value
, processor_arch
);
1678 strcpy(key_name
, "ProcessorArchitecture");
1681 hv_msg
->error
= HV_S_CONT
;
1685 * Send the value back to the kernel. The response is
1686 * already in the receive buffer. Update the cn_msg header to
1687 * reflect the key value that has been added to the message
1691 incoming_cn_msg
->id
.idx
= CN_KVP_IDX
;
1692 incoming_cn_msg
->id
.val
= CN_KVP_VAL
;
1693 incoming_cn_msg
->ack
= 0;
1694 incoming_cn_msg
->len
= sizeof(struct hv_kvp_msg
);
1696 len
= netlink_send(fd
, incoming_cn_msg
);
1698 syslog(LOG_ERR
, "net_link send failed; error:%d", len
);