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 char key
[HV_KVP_EXCHANGE_MAX_KEY_SIZE
];
107 char value
[HV_KVP_EXCHANGE_MAX_VALUE_SIZE
];
110 struct kvp_file_state
{
113 struct kvp_record
*records
;
115 char fname
[MAX_FILE_NAME
];
118 static struct kvp_file_state kvp_file_info
[KVP_POOL_COUNT
];
120 static void kvp_acquire_lock(int pool
)
122 struct flock fl
= {F_WRLCK
, SEEK_SET
, 0, 0, 0};
125 if (fcntl(kvp_file_info
[pool
].fd
, F_SETLKW
, &fl
) == -1) {
126 syslog(LOG_ERR
, "Failed to acquire the lock pool: %d", pool
);
131 static void kvp_release_lock(int pool
)
133 struct flock fl
= {F_UNLCK
, SEEK_SET
, 0, 0, 0};
136 if (fcntl(kvp_file_info
[pool
].fd
, F_SETLK
, &fl
) == -1) {
138 syslog(LOG_ERR
, "Failed to release the lock pool: %d", pool
);
143 static void kvp_update_file(int pool
)
146 size_t bytes_written
;
149 * We are going to write our in-memory registry out to
150 * disk; acquire the lock first.
152 kvp_acquire_lock(pool
);
154 filep
= fopen(kvp_file_info
[pool
].fname
, "we");
156 kvp_release_lock(pool
);
157 syslog(LOG_ERR
, "Failed to open file, pool: %d", pool
);
161 bytes_written
= fwrite(kvp_file_info
[pool
].records
,
162 sizeof(struct kvp_record
),
163 kvp_file_info
[pool
].num_records
, filep
);
165 if (ferror(filep
) || fclose(filep
)) {
166 kvp_release_lock(pool
);
167 syslog(LOG_ERR
, "Failed to write file, pool: %d", pool
);
171 kvp_release_lock(pool
);
174 static void kvp_update_mem_state(int pool
)
177 size_t records_read
= 0;
178 struct kvp_record
*record
= kvp_file_info
[pool
].records
;
179 struct kvp_record
*readp
;
180 int num_blocks
= kvp_file_info
[pool
].num_blocks
;
181 int alloc_unit
= sizeof(struct kvp_record
) * ENTRIES_PER_BLOCK
;
183 kvp_acquire_lock(pool
);
185 filep
= fopen(kvp_file_info
[pool
].fname
, "re");
187 kvp_release_lock(pool
);
188 syslog(LOG_ERR
, "Failed to open file, pool: %d", pool
);
192 readp
= &record
[records_read
];
193 records_read
+= fread(readp
, sizeof(struct kvp_record
),
194 ENTRIES_PER_BLOCK
* num_blocks
,
198 syslog(LOG_ERR
, "Failed to read file, pool: %d", pool
);
204 * We have more data to read.
207 record
= realloc(record
, alloc_unit
* num_blocks
);
209 if (record
== NULL
) {
210 syslog(LOG_ERR
, "malloc failed");
218 kvp_file_info
[pool
].num_blocks
= num_blocks
;
219 kvp_file_info
[pool
].records
= record
;
220 kvp_file_info
[pool
].num_records
= records_read
;
223 kvp_release_lock(pool
);
225 static int kvp_file_init(void)
231 struct kvp_record
*record
;
232 struct kvp_record
*readp
;
235 int alloc_unit
= sizeof(struct kvp_record
) * ENTRIES_PER_BLOCK
;
237 if (access(KVP_CONFIG_LOC
, F_OK
)) {
238 if (mkdir(KVP_CONFIG_LOC
, 0755 /* rwxr-xr-x */)) {
239 syslog(LOG_ERR
, " Failed to create %s", KVP_CONFIG_LOC
);
244 for (i
= 0; i
< KVP_POOL_COUNT
; i
++) {
245 fname
= kvp_file_info
[i
].fname
;
248 sprintf(fname
, "%s/.kvp_pool_%d", KVP_CONFIG_LOC
, i
);
249 fd
= open(fname
, O_RDWR
| O_CREAT
| O_CLOEXEC
, 0644 /* rw-r--r-- */);
255 filep
= fopen(fname
, "re");
259 record
= malloc(alloc_unit
* num_blocks
);
260 if (record
== NULL
) {
265 readp
= &record
[records_read
];
266 records_read
+= fread(readp
, sizeof(struct kvp_record
),
271 syslog(LOG_ERR
, "Failed to read file, pool: %d",
278 * We have more data to read.
281 record
= realloc(record
, alloc_unit
*
283 if (record
== NULL
) {
291 kvp_file_info
[i
].fd
= fd
;
292 kvp_file_info
[i
].num_blocks
= num_blocks
;
293 kvp_file_info
[i
].records
= record
;
294 kvp_file_info
[i
].num_records
= records_read
;
302 static int kvp_key_delete(int pool
, const char *key
, int key_size
)
307 struct kvp_record
*record
;
310 * First update the in-memory state.
312 kvp_update_mem_state(pool
);
314 num_records
= kvp_file_info
[pool
].num_records
;
315 record
= kvp_file_info
[pool
].records
;
317 for (i
= 0; i
< num_records
; i
++) {
318 if (memcmp(key
, record
[i
].key
, key_size
))
321 * Found a match; just move the remaining
324 if (i
== num_records
) {
325 kvp_file_info
[pool
].num_records
--;
326 kvp_update_file(pool
);
332 for (; k
< num_records
; k
++) {
333 strcpy(record
[j
].key
, record
[k
].key
);
334 strcpy(record
[j
].value
, record
[k
].value
);
338 kvp_file_info
[pool
].num_records
--;
339 kvp_update_file(pool
);
345 static int kvp_key_add_or_modify(int pool
, const char *key
, int key_size
, const char *value
,
350 struct kvp_record
*record
;
353 if ((key_size
> HV_KVP_EXCHANGE_MAX_KEY_SIZE
) ||
354 (value_size
> HV_KVP_EXCHANGE_MAX_VALUE_SIZE
))
358 * First update the in-memory state.
360 kvp_update_mem_state(pool
);
362 num_records
= kvp_file_info
[pool
].num_records
;
363 record
= kvp_file_info
[pool
].records
;
364 num_blocks
= kvp_file_info
[pool
].num_blocks
;
366 for (i
= 0; i
< num_records
; i
++) {
367 if (memcmp(key
, record
[i
].key
, key_size
))
370 * Found a match; just update the value -
371 * this is the modify case.
373 memcpy(record
[i
].value
, value
, value_size
);
374 kvp_update_file(pool
);
379 * Need to add a new entry;
381 if (num_records
== (ENTRIES_PER_BLOCK
* num_blocks
)) {
382 /* Need to allocate a larger array for reg entries. */
383 record
= realloc(record
, sizeof(struct kvp_record
) *
384 ENTRIES_PER_BLOCK
* (num_blocks
+ 1));
388 kvp_file_info
[pool
].num_blocks
++;
391 memcpy(record
[i
].value
, value
, value_size
);
392 memcpy(record
[i
].key
, key
, key_size
);
393 kvp_file_info
[pool
].records
= record
;
394 kvp_file_info
[pool
].num_records
++;
395 kvp_update_file(pool
);
399 static int kvp_get_value(int pool
, const char *key
, int key_size
, char *value
,
404 struct kvp_record
*record
;
406 if ((key_size
> HV_KVP_EXCHANGE_MAX_KEY_SIZE
) ||
407 (value_size
> HV_KVP_EXCHANGE_MAX_VALUE_SIZE
))
411 * First update the in-memory state.
413 kvp_update_mem_state(pool
);
415 num_records
= kvp_file_info
[pool
].num_records
;
416 record
= kvp_file_info
[pool
].records
;
418 for (i
= 0; i
< num_records
; i
++) {
419 if (memcmp(key
, record
[i
].key
, key_size
))
422 * Found a match; just copy the value out.
424 memcpy(value
, record
[i
].value
, value_size
);
431 static int kvp_pool_enumerate(int pool
, int index
, char *key
, int key_size
,
432 char *value
, int value_size
)
434 struct kvp_record
*record
;
437 * First update our in-memory database.
439 kvp_update_mem_state(pool
);
440 record
= kvp_file_info
[pool
].records
;
442 if (index
>= kvp_file_info
[pool
].num_records
) {
446 memcpy(key
, record
[index
].key
, key_size
);
447 memcpy(value
, record
[index
].value
, value_size
);
452 void kvp_get_os_info(void)
458 os_version
= uts_buf
.release
;
459 os_build
= strdup(uts_buf
.release
);
461 os_name
= uts_buf
.sysname
;
462 processor_arch
= uts_buf
.machine
;
465 * The current windows host (win7) expects the build
466 * string to be of the form: x.y.z
467 * Strip additional information we may have.
469 p
= strchr(os_version
, '-');
474 * Parse the /etc/os-release file if present:
475 * http://www.freedesktop.org/software/systemd/man/os-release.html
477 file
= fopen("/etc/os-release", "r");
479 while (fgets(buf
, sizeof(buf
), file
)) {
482 /* Ignore comments */
486 /* Split into name=value */
487 p
= strchr(buf
, '=');
492 /* Remove quotes and newline; un-escape */
501 } else if (*p
== '\'' || *p
== '"' ||
510 if (!strcmp(buf
, "NAME")) {
515 } else if (!strcmp(buf
, "VERSION_ID")) {
526 /* Fallback for older RH/SUSE releases */
527 file
= fopen("/etc/SuSE-release", "r");
529 goto kvp_osinfo_found
;
530 file
= fopen("/etc/redhat-release", "r");
532 goto kvp_osinfo_found
;
535 * We don't have information about the os.
540 /* up to three lines */
541 p
= fgets(buf
, sizeof(buf
), file
);
543 p
= strchr(buf
, '\n');
552 p
= fgets(buf
, sizeof(buf
), file
);
554 p
= strchr(buf
, '\n');
563 p
= fgets(buf
, sizeof(buf
), file
);
565 p
= strchr(buf
, '\n');
583 * Retrieve an interface name corresponding to the specified guid.
584 * If there is a match, the function returns a pointer
585 * to the interface name and if not, a NULL is returned.
586 * If a match is found, the caller is responsible for
587 * freeing the memory.
590 static char *kvp_get_if_name(char *guid
)
593 struct dirent
*entry
;
596 char *if_name
= NULL
;
598 char *kvp_net_dir
= "/sys/class/net/";
601 dir
= opendir(kvp_net_dir
);
605 snprintf(dev_id
, sizeof(dev_id
), "%s", kvp_net_dir
);
606 q
= dev_id
+ strlen(kvp_net_dir
);
608 while ((entry
= readdir(dir
)) != NULL
) {
610 * Set the state for the next pass.
613 strcat(dev_id
, entry
->d_name
);
614 strcat(dev_id
, "/device/device_id");
616 file
= fopen(dev_id
, "r");
620 p
= fgets(buf
, sizeof(buf
), file
);
626 if (!strcmp(p
, guid
)) {
628 * Found the guid match; return the interface
629 * name. The caller will free the memory.
631 if_name
= strdup(entry
->d_name
);
644 * Retrieve the MAC address given the interface name.
647 static char *kvp_if_name_to_mac(char *if_name
)
654 char *mac_addr
= NULL
;
656 snprintf(addr_file
, sizeof(addr_file
), "%s%s%s", "/sys/class/net/",
657 if_name
, "/address");
659 file
= fopen(addr_file
, "r");
663 p
= fgets(buf
, sizeof(buf
), file
);
668 for (i
= 0; i
< strlen(p
); i
++)
669 p
[i
] = toupper(p
[i
]);
670 mac_addr
= strdup(p
);
679 * Retrieve the interface name given tha MAC address.
682 static char *kvp_mac_to_if_name(char *mac
)
685 struct dirent
*entry
;
688 char *if_name
= NULL
;
690 char *kvp_net_dir
= "/sys/class/net/";
694 dir
= opendir(kvp_net_dir
);
698 snprintf(dev_id
, sizeof(dev_id
), kvp_net_dir
);
699 q
= dev_id
+ strlen(kvp_net_dir
);
701 while ((entry
= readdir(dir
)) != NULL
) {
703 * Set the state for the next pass.
707 strcat(dev_id
, entry
->d_name
);
708 strcat(dev_id
, "/address");
710 file
= fopen(dev_id
, "r");
714 p
= fgets(buf
, sizeof(buf
), file
);
720 for (i
= 0; i
< strlen(p
); i
++)
721 p
[i
] = toupper(p
[i
]);
723 if (!strcmp(p
, mac
)) {
725 * Found the MAC match; return the interface
726 * name. The caller will free the memory.
728 if_name
= strdup(entry
->d_name
);
741 static void kvp_process_ipconfig_file(char *cmd
,
742 char *config_buf
, int len
,
743 int element_size
, int offset
)
751 * First execute the command.
753 file
= popen(cmd
, "r");
758 memset(config_buf
, 0, len
);
759 while ((p
= fgets(buf
, sizeof(buf
), file
)) != NULL
) {
760 if ((len
- strlen(config_buf
)) < (element_size
+ 1))
765 strcat(config_buf
, p
);
766 strcat(config_buf
, ";");
771 static void kvp_get_ipconfig_info(char *if_name
,
772 struct hv_kvp_ipaddr_value
*buffer
)
780 * Get the address of default gateway (ipv4).
782 sprintf(cmd
, "%s %s", "ip route show dev", if_name
);
783 strcat(cmd
, " | awk '/default/ {print $3 }'");
786 * Execute the command to gather gateway info.
788 kvp_process_ipconfig_file(cmd
, (char *)buffer
->gate_way
,
789 (MAX_GATEWAY_SIZE
* 2), INET_ADDRSTRLEN
, 0);
792 * Get the address of default gateway (ipv6).
794 sprintf(cmd
, "%s %s", "ip -f inet6 route show dev", if_name
);
795 strcat(cmd
, " | awk '/default/ {print $3 }'");
798 * Execute the command to gather gateway info (ipv6).
800 kvp_process_ipconfig_file(cmd
, (char *)buffer
->gate_way
,
801 (MAX_GATEWAY_SIZE
* 2), INET6_ADDRSTRLEN
, 1);
805 * Gather the DNS state.
806 * Since there is no standard way to get this information
807 * across various distributions of interest; we just invoke
808 * an external script that needs to be ported across distros
811 * Following is the expected format of the information from the script:
813 * ipaddr1 (nameserver1)
814 * ipaddr2 (nameserver2)
819 sprintf(cmd
, "%s", "hv_get_dns_info");
822 * Execute the command to gather DNS info.
824 kvp_process_ipconfig_file(cmd
, (char *)buffer
->dns_addr
,
825 (MAX_IP_ADDR_SIZE
* 2), INET_ADDRSTRLEN
, 0);
828 * Gather the DHCP state.
829 * We will gather this state by invoking an external script.
830 * The parameter to the script is the interface name.
831 * Here is the expected output:
833 * Enabled: DHCP enabled.
836 sprintf(cmd
, "%s %s", "hv_get_dhcp_info", if_name
);
838 file
= popen(cmd
, "r");
842 p
= fgets(dhcp_info
, sizeof(dhcp_info
), file
);
848 if (!strncmp(p
, "Enabled", 7))
849 buffer
->dhcp_enabled
= 1;
851 buffer
->dhcp_enabled
= 0;
857 static unsigned int hweight32(unsigned int *w
)
859 unsigned int res
= *w
- ((*w
>> 1) & 0x55555555);
860 res
= (res
& 0x33333333) + ((res
>> 2) & 0x33333333);
861 res
= (res
+ (res
>> 4)) & 0x0F0F0F0F;
862 res
= res
+ (res
>> 8);
863 return (res
+ (res
>> 16)) & 0x000000FF;
866 static int kvp_process_ip_address(void *addrp
,
867 int family
, char *buffer
,
868 int length
, int *offset
)
870 struct sockaddr_in
*addr
;
871 struct sockaddr_in6
*addr6
;
876 if (family
== AF_INET
) {
877 addr
= (struct sockaddr_in
*)addrp
;
878 str
= inet_ntop(family
, &addr
->sin_addr
, tmp
, 50);
879 addr_length
= INET_ADDRSTRLEN
;
881 addr6
= (struct sockaddr_in6
*)addrp
;
882 str
= inet_ntop(family
, &addr6
->sin6_addr
.s6_addr
, tmp
, 50);
883 addr_length
= INET6_ADDRSTRLEN
;
886 if ((length
- *offset
) < addr_length
+ 2)
889 strcpy(buffer
, "inet_ntop failed\n");
899 *offset
+= strlen(str
) + 1;
905 kvp_get_ip_info(int family
, char *if_name
, int op
,
906 void *out_buffer
, int length
)
908 struct ifaddrs
*ifap
;
909 struct ifaddrs
*curp
;
914 struct hv_kvp_ipaddr_value
*ip_buffer
;
915 char cidr_mask
[5]; /* /xyz */
920 struct sockaddr_in6
*addr6
;
922 if (op
== KVP_OP_ENUMERATE
) {
925 ip_buffer
= out_buffer
;
926 buffer
= (char *)ip_buffer
->ip_addr
;
927 ip_buffer
->addr_family
= 0;
930 * On entry into this function, the buffer is capable of holding the
934 if (getifaddrs(&ifap
)) {
935 strcpy(buffer
, "getifaddrs failed\n");
940 while (curp
!= NULL
) {
941 if (curp
->ifa_addr
== NULL
) {
942 curp
= curp
->ifa_next
;
946 if ((if_name
!= NULL
) &&
947 (strncmp(curp
->ifa_name
, if_name
, strlen(if_name
)))) {
949 * We want info about a specific interface;
952 curp
= curp
->ifa_next
;
957 * We only support two address families: AF_INET and AF_INET6.
958 * If a family value of 0 is specified, we collect both
959 * supported address families; if not we gather info on
960 * the specified address family.
962 if ((((family
!= 0) &&
963 (curp
->ifa_addr
->sa_family
!= family
))) ||
964 (curp
->ifa_flags
& IFF_LOOPBACK
)) {
965 curp
= curp
->ifa_next
;
968 if ((curp
->ifa_addr
->sa_family
!= AF_INET
) &&
969 (curp
->ifa_addr
->sa_family
!= AF_INET6
)) {
970 curp
= curp
->ifa_next
;
974 if (op
== KVP_OP_GET_IP_INFO
) {
976 * Gather info other than the IP address.
977 * IP address info will be gathered later.
979 if (curp
->ifa_addr
->sa_family
== AF_INET
) {
980 ip_buffer
->addr_family
|= ADDR_FAMILY_IPV4
;
984 error
= kvp_process_ip_address(
994 ip_buffer
->addr_family
|= ADDR_FAMILY_IPV6
;
997 * Get subnet info in CIDR format.
1000 sn_str
= (char *)ip_buffer
->sub_net
;
1001 addr6
= (struct sockaddr_in6
*)
1003 w
= addr6
->sin6_addr
.s6_addr32
;
1005 for (i
= 0; i
< 4; i
++)
1006 weight
+= hweight32(&w
[i
]);
1008 sprintf(cidr_mask
, "/%d", weight
);
1009 if ((length
- sn_offset
) <
1010 (strlen(cidr_mask
) + 1))
1014 strcpy(sn_str
, cidr_mask
);
1016 strcat(sn_str
, cidr_mask
);
1017 strcat((char *)ip_buffer
->sub_net
, ";");
1018 sn_offset
+= strlen(sn_str
) + 1;
1022 * Collect other ip related configuration info.
1025 kvp_get_ipconfig_info(if_name
, ip_buffer
);
1029 error
= kvp_process_ip_address(curp
->ifa_addr
,
1030 curp
->ifa_addr
->sa_family
,
1036 curp
= curp
->ifa_next
;
1045 static int expand_ipv6(char *addr
, int type
)
1048 struct in6_addr v6_addr
;
1050 ret
= inet_pton(AF_INET6
, addr
, &v6_addr
);
1053 if (type
== NETMASK
)
1058 sprintf(addr
, "%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:"
1059 "%02x%02x:%02x%02x:%02x%02x",
1060 (int)v6_addr
.s6_addr
[0], (int)v6_addr
.s6_addr
[1],
1061 (int)v6_addr
.s6_addr
[2], (int)v6_addr
.s6_addr
[3],
1062 (int)v6_addr
.s6_addr
[4], (int)v6_addr
.s6_addr
[5],
1063 (int)v6_addr
.s6_addr
[6], (int)v6_addr
.s6_addr
[7],
1064 (int)v6_addr
.s6_addr
[8], (int)v6_addr
.s6_addr
[9],
1065 (int)v6_addr
.s6_addr
[10], (int)v6_addr
.s6_addr
[11],
1066 (int)v6_addr
.s6_addr
[12], (int)v6_addr
.s6_addr
[13],
1067 (int)v6_addr
.s6_addr
[14], (int)v6_addr
.s6_addr
[15]);
1073 static int is_ipv4(char *addr
)
1076 struct in_addr ipv4_addr
;
1078 ret
= inet_pton(AF_INET
, addr
, &ipv4_addr
);
1085 static int parse_ip_val_buffer(char *in_buf
, int *offset
,
1086 char *out_buf
, int out_len
)
1092 * in_buf has sequence of characters that are seperated by
1093 * the character ';'. The last sequence does not have the
1094 * terminating ";" character.
1096 start
= in_buf
+ *offset
;
1098 x
= strchr(start
, ';');
1102 x
= start
+ strlen(start
);
1104 if (strlen(start
) != 0) {
1107 * Get rid of leading spaces.
1109 while (start
[i
] == ' ')
1112 if ((x
- start
) <= out_len
) {
1113 strcpy(out_buf
, (start
+ i
));
1114 *offset
+= (x
- start
) + 1;
1121 static int kvp_write_file(FILE *f
, char *s1
, char *s2
, char *s3
)
1125 ret
= fprintf(f
, "%s%s%s%s\n", s1
, s2
, "=", s3
);
1134 static int process_ip_string(FILE *f
, char *ip_string
, int type
)
1137 char addr
[INET6_ADDRSTRLEN
];
1144 memset(addr
, 0, sizeof(addr
));
1146 while (parse_ip_val_buffer(ip_string
, &offset
, addr
,
1147 (MAX_IP_ADDR_SIZE
* 2))) {
1150 if (is_ipv4(addr
)) {
1153 snprintf(str
, sizeof(str
), "%s", "IPADDR");
1156 snprintf(str
, sizeof(str
), "%s", "NETMASK");
1159 snprintf(str
, sizeof(str
), "%s", "GATEWAY");
1162 snprintf(str
, sizeof(str
), "%s", "DNS");
1167 snprintf(sub_str
, sizeof(sub_str
), "%d", ++i
);
1168 } else if (type
== GATEWAY
&& i
== 0) {
1171 snprintf(sub_str
, sizeof(sub_str
), "%d", i
++);
1175 } else if (expand_ipv6(addr
, type
)) {
1178 snprintf(str
, sizeof(str
), "%s", "IPV6ADDR");
1181 snprintf(str
, sizeof(str
), "%s", "IPV6NETMASK");
1184 snprintf(str
, sizeof(str
), "%s",
1188 snprintf(str
, sizeof(str
), "%s", "DNS");
1193 snprintf(sub_str
, sizeof(sub_str
), "%d", ++i
);
1194 } else if (j
== 0) {
1197 snprintf(sub_str
, sizeof(sub_str
), "_%d", j
++);
1200 return HV_INVALIDARG
;
1203 error
= kvp_write_file(f
, str
, sub_str
, addr
);
1206 memset(addr
, 0, sizeof(addr
));
1212 static int kvp_set_ip_info(char *if_name
, struct hv_kvp_ipaddr_value
*new_val
)
1221 * Set the configuration for the specified interface with
1222 * the information provided. Since there is no standard
1223 * way to configure an interface, we will have an external
1224 * script that does the job of configuring the interface and
1225 * flushing the configuration.
1227 * The parameters passed to this external script are:
1228 * 1. A configuration file that has the specified configuration.
1230 * We will embed the name of the interface in the configuration
1231 * file: ifcfg-ethx (where ethx is the interface name).
1233 * The information provided here may be more than what is needed
1234 * in a given distro to configure the interface and so are free
1235 * ignore information that may not be relevant.
1237 * Here is the format of the ip configuration file:
1240 * DEVICE=interface name
1241 * BOOTPROTO=<protocol> (where <protocol> is "dhcp" if DHCP is configured
1242 * or "none" if no boot-time protocol should be used)
1246 * IPADDRx=ipaddry (where y = x + 1)
1249 * NETMASKx=netmasky (where y = x + 1)
1252 * GATEWAYx=ipaddry (where y = x + 1)
1254 * DNSx=ipaddrx (where first DNS address is tagged as DNS1 etc)
1256 * IPV6 addresses will be tagged as IPV6ADDR, IPV6 gateway will be
1257 * tagged as IPV6_DEFAULTGW and IPV6 NETMASK will be tagged as
1260 * The host can specify multiple ipv4 and ipv6 addresses to be
1261 * configured for the interface. Furthermore, the configuration
1262 * needs to be persistent. A subsequent GET call on the interface
1263 * is expected to return the configuration that is set via the SET
1267 snprintf(if_file
, sizeof(if_file
), "%s%s%s", KVP_CONFIG_LOC
,
1268 "/ifcfg-", if_name
);
1270 file
= fopen(if_file
, "w");
1273 syslog(LOG_ERR
, "Failed to open config file");
1278 * First write out the MAC address.
1281 mac_addr
= kvp_if_name_to_mac(if_name
);
1282 if (mac_addr
== NULL
) {
1287 error
= kvp_write_file(file
, "HWADDR", "", mac_addr
);
1291 error
= kvp_write_file(file
, "DEVICE", "", if_name
);
1295 if (new_val
->dhcp_enabled
) {
1296 error
= kvp_write_file(file
, "BOOTPROTO", "", "dhcp");
1306 error
= kvp_write_file(file
, "BOOTPROTO", "", "none");
1312 * Write the configuration for ipaddress, netmask, gateway and
1316 error
= process_ip_string(file
, (char *)new_val
->ip_addr
, IPADDR
);
1320 error
= process_ip_string(file
, (char *)new_val
->sub_net
, NETMASK
);
1324 error
= process_ip_string(file
, (char *)new_val
->gate_way
, GATEWAY
);
1328 error
= process_ip_string(file
, (char *)new_val
->dns_addr
, DNS
);
1337 * Now that we have populated the configuration file,
1338 * invoke the external script to do its magic.
1341 snprintf(cmd
, sizeof(cmd
), "%s %s", "hv_set_ifconfig", if_file
);
1346 syslog(LOG_ERR
, "Failed to write config file");
1354 kvp_get_domain_name(char *buffer
, int length
)
1356 struct addrinfo hints
, *info
;
1359 gethostname(buffer
, length
);
1360 memset(&hints
, 0, sizeof(hints
));
1361 hints
.ai_family
= AF_INET
; /*Get only ipv4 addrinfo. */
1362 hints
.ai_socktype
= SOCK_STREAM
;
1363 hints
.ai_flags
= AI_CANONNAME
;
1365 error
= getaddrinfo(buffer
, NULL
, &hints
, &info
);
1367 strcpy(buffer
, "getaddrinfo failed\n");
1370 strcpy(buffer
, info
->ai_canonname
);
1376 netlink_send(int fd
, struct cn_msg
*msg
)
1378 struct nlmsghdr
*nlh
;
1380 struct msghdr message
;
1382 struct iovec iov
[2];
1384 size
= NLMSG_SPACE(sizeof(struct cn_msg
) + msg
->len
);
1386 nlh
= (struct nlmsghdr
*)buffer
;
1388 nlh
->nlmsg_pid
= getpid();
1389 nlh
->nlmsg_type
= NLMSG_DONE
;
1390 nlh
->nlmsg_len
= NLMSG_LENGTH(size
- sizeof(*nlh
));
1391 nlh
->nlmsg_flags
= 0;
1393 iov
[0].iov_base
= nlh
;
1394 iov
[0].iov_len
= sizeof(*nlh
);
1396 iov
[1].iov_base
= msg
;
1397 iov
[1].iov_len
= size
;
1399 memset(&message
, 0, sizeof(message
));
1400 message
.msg_name
= &addr
;
1401 message
.msg_namelen
= sizeof(addr
);
1402 message
.msg_iov
= iov
;
1403 message
.msg_iovlen
= 2;
1405 return sendmsg(fd
, &message
, 0);
1410 int fd
, len
, sock_opt
;
1412 struct cn_msg
*message
;
1414 struct nlmsghdr
*incoming_msg
;
1415 struct cn_msg
*incoming_cn_msg
;
1416 struct hv_kvp_msg
*hv_msg
;
1423 struct hv_kvp_ipaddr_value
*kvp_ip_val
;
1426 openlog("KVP", 0, LOG_USER
);
1427 syslog(LOG_INFO
, "KVP starting; pid is:%d", getpid());
1429 * Retrieve OS release information.
1433 if (kvp_file_init()) {
1434 syslog(LOG_ERR
, "Failed to initialize the pools");
1438 fd
= socket(AF_NETLINK
, SOCK_DGRAM
, NETLINK_CONNECTOR
);
1440 syslog(LOG_ERR
, "netlink socket creation failed; error:%d", fd
);
1443 addr
.nl_family
= AF_NETLINK
;
1446 addr
.nl_groups
= CN_KVP_IDX
;
1449 error
= bind(fd
, (struct sockaddr
*)&addr
, sizeof(addr
));
1451 syslog(LOG_ERR
, "bind failed; error:%d", error
);
1455 sock_opt
= addr
.nl_groups
;
1456 setsockopt(fd
, 270, 1, &sock_opt
, sizeof(sock_opt
));
1458 * Register ourselves with the kernel.
1460 message
= (struct cn_msg
*)kvp_send_buffer
;
1461 message
->id
.idx
= CN_KVP_IDX
;
1462 message
->id
.val
= CN_KVP_VAL
;
1464 hv_msg
= (struct hv_kvp_msg
*)message
->data
;
1465 hv_msg
->kvp_hdr
.operation
= KVP_OP_REGISTER1
;
1467 message
->len
= sizeof(struct hv_kvp_msg
);
1469 len
= netlink_send(fd
, message
);
1471 syslog(LOG_ERR
, "netlink_send failed; error:%d", len
);
1479 struct sockaddr
*addr_p
= (struct sockaddr
*) &addr
;
1480 socklen_t addr_l
= sizeof(addr
);
1481 pfd
.events
= POLLIN
;
1485 len
= recvfrom(fd
, kvp_recv_buffer
, sizeof(kvp_recv_buffer
), 0,
1489 syslog(LOG_ERR
, "recvfrom failed; pid:%u error:%d %s",
1490 addr
.nl_pid
, errno
, strerror(errno
));
1496 syslog(LOG_WARNING
, "Received packet from untrusted pid:%u",
1501 incoming_msg
= (struct nlmsghdr
*)kvp_recv_buffer
;
1502 incoming_cn_msg
= (struct cn_msg
*)NLMSG_DATA(incoming_msg
);
1503 hv_msg
= (struct hv_kvp_msg
*)incoming_cn_msg
->data
;
1506 * We will use the KVP header information to pass back
1507 * the error from this daemon. So, first copy the state
1508 * and set the error code to success.
1510 op
= hv_msg
->kvp_hdr
.operation
;
1511 pool
= hv_msg
->kvp_hdr
.pool
;
1512 hv_msg
->error
= HV_S_OK
;
1514 if ((in_hand_shake
) && (op
== KVP_OP_REGISTER1
)) {
1516 * Driver is registering with us; stash away the version
1520 p
= (char *)hv_msg
->body
.kvp_register
.version
;
1521 lic_version
= malloc(strlen(p
) + 1);
1523 strcpy(lic_version
, p
);
1524 syslog(LOG_INFO
, "KVP LIC Version: %s",
1527 syslog(LOG_ERR
, "malloc failed");
1533 case KVP_OP_GET_IP_INFO
:
1534 kvp_ip_val
= &hv_msg
->body
.kvp_ip_val
;
1536 kvp_mac_to_if_name((char *)kvp_ip_val
->adapter_id
);
1538 if (if_name
== NULL
) {
1540 * We could not map the mac address to an
1541 * interface name; return error.
1543 hv_msg
->error
= HV_E_FAIL
;
1546 error
= kvp_get_ip_info(
1547 0, if_name
, KVP_OP_GET_IP_INFO
,
1549 (MAX_IP_ADDR_SIZE
* 2));
1552 hv_msg
->error
= error
;
1557 case KVP_OP_SET_IP_INFO
:
1558 kvp_ip_val
= &hv_msg
->body
.kvp_ip_val
;
1559 if_name
= kvp_get_if_name(
1560 (char *)kvp_ip_val
->adapter_id
);
1561 if (if_name
== NULL
) {
1563 * We could not map the guid to an
1564 * interface name; return error.
1566 hv_msg
->error
= HV_GUID_NOTFOUND
;
1569 error
= kvp_set_ip_info(if_name
, kvp_ip_val
);
1571 hv_msg
->error
= error
;
1577 if (kvp_key_add_or_modify(pool
,
1578 hv_msg
->body
.kvp_set
.data
.key
,
1579 hv_msg
->body
.kvp_set
.data
.key_size
,
1580 hv_msg
->body
.kvp_set
.data
.value
,
1581 hv_msg
->body
.kvp_set
.data
.value_size
))
1582 hv_msg
->error
= HV_S_CONT
;
1586 if (kvp_get_value(pool
,
1587 hv_msg
->body
.kvp_set
.data
.key
,
1588 hv_msg
->body
.kvp_set
.data
.key_size
,
1589 hv_msg
->body
.kvp_set
.data
.value
,
1590 hv_msg
->body
.kvp_set
.data
.value_size
))
1591 hv_msg
->error
= HV_S_CONT
;
1595 if (kvp_key_delete(pool
,
1596 hv_msg
->body
.kvp_delete
.key
,
1597 hv_msg
->body
.kvp_delete
.key_size
))
1598 hv_msg
->error
= HV_S_CONT
;
1605 if (op
!= KVP_OP_ENUMERATE
)
1609 * If the pool is KVP_POOL_AUTO, dynamically generate
1610 * both the key and the value; if not read from the
1613 if (pool
!= KVP_POOL_AUTO
) {
1614 if (kvp_pool_enumerate(pool
,
1615 hv_msg
->body
.kvp_enum_data
.index
,
1616 hv_msg
->body
.kvp_enum_data
.data
.key
,
1617 HV_KVP_EXCHANGE_MAX_KEY_SIZE
,
1618 hv_msg
->body
.kvp_enum_data
.data
.value
,
1619 HV_KVP_EXCHANGE_MAX_VALUE_SIZE
))
1620 hv_msg
->error
= HV_S_CONT
;
1624 hv_msg
= (struct hv_kvp_msg
*)incoming_cn_msg
->data
;
1625 key_name
= (char *)hv_msg
->body
.kvp_enum_data
.data
.key
;
1626 key_value
= (char *)hv_msg
->body
.kvp_enum_data
.data
.value
;
1628 switch (hv_msg
->body
.kvp_enum_data
.index
) {
1629 case FullyQualifiedDomainName
:
1630 kvp_get_domain_name(key_value
,
1631 HV_KVP_EXCHANGE_MAX_VALUE_SIZE
);
1632 strcpy(key_name
, "FullyQualifiedDomainName");
1634 case IntegrationServicesVersion
:
1635 strcpy(key_name
, "IntegrationServicesVersion");
1636 strcpy(key_value
, lic_version
);
1638 case NetworkAddressIPv4
:
1639 kvp_get_ip_info(AF_INET
, NULL
, KVP_OP_ENUMERATE
,
1640 key_value
, HV_KVP_EXCHANGE_MAX_VALUE_SIZE
);
1641 strcpy(key_name
, "NetworkAddressIPv4");
1643 case NetworkAddressIPv6
:
1644 kvp_get_ip_info(AF_INET6
, NULL
, KVP_OP_ENUMERATE
,
1645 key_value
, HV_KVP_EXCHANGE_MAX_VALUE_SIZE
);
1646 strcpy(key_name
, "NetworkAddressIPv6");
1649 strcpy(key_value
, os_build
);
1650 strcpy(key_name
, "OSBuildNumber");
1653 strcpy(key_value
, os_name
);
1654 strcpy(key_name
, "OSName");
1656 case OSMajorVersion
:
1657 strcpy(key_value
, os_major
);
1658 strcpy(key_name
, "OSMajorVersion");
1660 case OSMinorVersion
:
1661 strcpy(key_value
, os_minor
);
1662 strcpy(key_name
, "OSMinorVersion");
1665 strcpy(key_value
, os_version
);
1666 strcpy(key_name
, "OSVersion");
1668 case ProcessorArchitecture
:
1669 strcpy(key_value
, processor_arch
);
1670 strcpy(key_name
, "ProcessorArchitecture");
1673 hv_msg
->error
= HV_S_CONT
;
1677 * Send the value back to the kernel. The response is
1678 * already in the receive buffer. Update the cn_msg header to
1679 * reflect the key value that has been added to the message
1683 incoming_cn_msg
->id
.idx
= CN_KVP_IDX
;
1684 incoming_cn_msg
->id
.val
= CN_KVP_VAL
;
1685 incoming_cn_msg
->ack
= 0;
1686 incoming_cn_msg
->len
= sizeof(struct hv_kvp_msg
);
1688 len
= netlink_send(fd
, incoming_cn_msg
);
1690 syslog(LOG_ERR
, "net_link send failed; error:%d", len
);