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>
35 #include <arpa/inet.h>
36 #include <linux/connector.h>
37 #include <linux/hyperv.h>
38 #include <linux/netlink.h>
46 * KVP protocol: The user mode component first registers with the
47 * the kernel component. Subsequently, the kernel component requests, data
48 * for the specified keys. In response to this message the user mode component
49 * fills in the value corresponding to the specified key. We overload the
50 * sequence field in the cn_msg header to define our KVP message types.
52 * We use this infrastructure for also supporting queries from user mode
53 * application for state that may be maintained in the KVP kernel component.
59 FullyQualifiedDomainName
= 0,
60 IntegrationServicesVersion
, /*This key is serviced in the kernel*/
71 static char kvp_send_buffer
[4096];
72 static char kvp_recv_buffer
[4096 * 2];
73 static struct sockaddr_nl addr
;
74 static int in_hand_shake
= 1;
76 static char *os_name
= "";
77 static char *os_major
= "";
78 static char *os_minor
= "";
79 static char *processor_arch
;
80 static char *os_build
;
81 static char *lic_version
= "Unknown version";
82 static struct utsname uts_buf
;
85 #define MAX_FILE_NAME 100
86 #define ENTRIES_PER_BLOCK 50
89 __u8 key
[HV_KVP_EXCHANGE_MAX_KEY_SIZE
];
90 __u8 value
[HV_KVP_EXCHANGE_MAX_VALUE_SIZE
];
93 struct kvp_file_state
{
96 struct kvp_record
*records
;
98 __u8 fname
[MAX_FILE_NAME
];
101 static struct kvp_file_state kvp_file_info
[KVP_POOL_COUNT
];
103 static void kvp_acquire_lock(int pool
)
105 struct flock fl
= {F_WRLCK
, SEEK_SET
, 0, 0, 0};
108 if (fcntl(kvp_file_info
[pool
].fd
, F_SETLKW
, &fl
) == -1) {
109 syslog(LOG_ERR
, "Failed to acquire the lock pool: %d", pool
);
114 static void kvp_release_lock(int pool
)
116 struct flock fl
= {F_UNLCK
, SEEK_SET
, 0, 0, 0};
119 if (fcntl(kvp_file_info
[pool
].fd
, F_SETLK
, &fl
) == -1) {
121 syslog(LOG_ERR
, "Failed to release the lock pool: %d", pool
);
126 static void kvp_update_file(int pool
)
129 size_t bytes_written
;
132 * We are going to write our in-memory registry out to
133 * disk; acquire the lock first.
135 kvp_acquire_lock(pool
);
137 filep
= fopen(kvp_file_info
[pool
].fname
, "w");
139 kvp_release_lock(pool
);
140 syslog(LOG_ERR
, "Failed to open file, pool: %d", pool
);
144 bytes_written
= fwrite(kvp_file_info
[pool
].records
,
145 sizeof(struct kvp_record
),
146 kvp_file_info
[pool
].num_records
, filep
);
149 kvp_release_lock(pool
);
152 static void kvp_update_mem_state(int pool
)
155 size_t records_read
= 0;
156 struct kvp_record
*record
= kvp_file_info
[pool
].records
;
157 struct kvp_record
*readp
;
158 int num_blocks
= kvp_file_info
[pool
].num_blocks
;
159 int alloc_unit
= sizeof(struct kvp_record
) * ENTRIES_PER_BLOCK
;
161 kvp_acquire_lock(pool
);
163 filep
= fopen(kvp_file_info
[pool
].fname
, "r");
165 kvp_release_lock(pool
);
166 syslog(LOG_ERR
, "Failed to open file, pool: %d", pool
);
169 while (!feof(filep
)) {
170 readp
= &record
[records_read
];
171 records_read
+= fread(readp
, sizeof(struct kvp_record
),
172 ENTRIES_PER_BLOCK
* num_blocks
,
177 * We have more data to read.
180 record
= realloc(record
, alloc_unit
* num_blocks
);
182 if (record
== NULL
) {
183 syslog(LOG_ERR
, "malloc failed");
191 kvp_file_info
[pool
].num_blocks
= num_blocks
;
192 kvp_file_info
[pool
].records
= record
;
193 kvp_file_info
[pool
].num_records
= records_read
;
195 kvp_release_lock(pool
);
197 static int kvp_file_init(void)
203 struct kvp_record
*record
;
204 struct kvp_record
*readp
;
207 int alloc_unit
= sizeof(struct kvp_record
) * ENTRIES_PER_BLOCK
;
209 if (access("/var/opt/hyperv", F_OK
)) {
210 if (mkdir("/var/opt/hyperv", S_IRUSR
| S_IWUSR
| S_IROTH
)) {
211 syslog(LOG_ERR
, " Failed to create /var/opt/hyperv");
216 for (i
= 0; i
< KVP_POOL_COUNT
; i
++) {
217 fname
= kvp_file_info
[i
].fname
;
220 sprintf(fname
, "/var/opt/hyperv/.kvp_pool_%d", i
);
221 fd
= open(fname
, O_RDWR
| O_CREAT
, S_IRUSR
| S_IWUSR
| S_IROTH
);
227 filep
= fopen(fname
, "r");
231 record
= malloc(alloc_unit
* num_blocks
);
232 if (record
== NULL
) {
236 while (!feof(filep
)) {
237 readp
= &record
[records_read
];
238 records_read
+= fread(readp
, sizeof(struct kvp_record
),
244 * We have more data to read.
247 record
= realloc(record
, alloc_unit
*
249 if (record
== NULL
) {
257 kvp_file_info
[i
].fd
= fd
;
258 kvp_file_info
[i
].num_blocks
= num_blocks
;
259 kvp_file_info
[i
].records
= record
;
260 kvp_file_info
[i
].num_records
= records_read
;
268 static int kvp_key_delete(int pool
, __u8
*key
, int key_size
)
273 struct kvp_record
*record
;
276 * First update the in-memory state.
278 kvp_update_mem_state(pool
);
280 num_records
= kvp_file_info
[pool
].num_records
;
281 record
= kvp_file_info
[pool
].records
;
283 for (i
= 0; i
< num_records
; i
++) {
284 if (memcmp(key
, record
[i
].key
, key_size
))
287 * Found a match; just move the remaining
290 if (i
== num_records
) {
291 kvp_file_info
[pool
].num_records
--;
292 kvp_update_file(pool
);
298 for (; k
< num_records
; k
++) {
299 strcpy(record
[j
].key
, record
[k
].key
);
300 strcpy(record
[j
].value
, record
[k
].value
);
304 kvp_file_info
[pool
].num_records
--;
305 kvp_update_file(pool
);
311 static int kvp_key_add_or_modify(int pool
, __u8
*key
, int key_size
, __u8
*value
,
316 struct kvp_record
*record
;
319 if ((key_size
> HV_KVP_EXCHANGE_MAX_KEY_SIZE
) ||
320 (value_size
> HV_KVP_EXCHANGE_MAX_VALUE_SIZE
))
324 * First update the in-memory state.
326 kvp_update_mem_state(pool
);
328 num_records
= kvp_file_info
[pool
].num_records
;
329 record
= kvp_file_info
[pool
].records
;
330 num_blocks
= kvp_file_info
[pool
].num_blocks
;
332 for (i
= 0; i
< num_records
; i
++) {
333 if (memcmp(key
, record
[i
].key
, key_size
))
336 * Found a match; just update the value -
337 * this is the modify case.
339 memcpy(record
[i
].value
, value
, value_size
);
340 kvp_update_file(pool
);
345 * Need to add a new entry;
347 if (num_records
== (ENTRIES_PER_BLOCK
* num_blocks
)) {
348 /* Need to allocate a larger array for reg entries. */
349 record
= realloc(record
, sizeof(struct kvp_record
) *
350 ENTRIES_PER_BLOCK
* (num_blocks
+ 1));
354 kvp_file_info
[pool
].num_blocks
++;
357 memcpy(record
[i
].value
, value
, value_size
);
358 memcpy(record
[i
].key
, key
, key_size
);
359 kvp_file_info
[pool
].records
= record
;
360 kvp_file_info
[pool
].num_records
++;
361 kvp_update_file(pool
);
365 static int kvp_get_value(int pool
, __u8
*key
, int key_size
, __u8
*value
,
370 struct kvp_record
*record
;
372 if ((key_size
> HV_KVP_EXCHANGE_MAX_KEY_SIZE
) ||
373 (value_size
> HV_KVP_EXCHANGE_MAX_VALUE_SIZE
))
377 * First update the in-memory state.
379 kvp_update_mem_state(pool
);
381 num_records
= kvp_file_info
[pool
].num_records
;
382 record
= kvp_file_info
[pool
].records
;
384 for (i
= 0; i
< num_records
; i
++) {
385 if (memcmp(key
, record
[i
].key
, key_size
))
388 * Found a match; just copy the value out.
390 memcpy(value
, record
[i
].value
, value_size
);
397 static int kvp_pool_enumerate(int pool
, int index
, __u8
*key
, int key_size
,
398 __u8
*value
, int value_size
)
400 struct kvp_record
*record
;
403 * First update our in-memory database.
405 kvp_update_mem_state(pool
);
406 record
= kvp_file_info
[pool
].records
;
408 if (index
>= kvp_file_info
[pool
].num_records
) {
412 memcpy(key
, record
[index
].key
, key_size
);
413 memcpy(value
, record
[index
].value
, value_size
);
418 void kvp_get_os_info(void)
424 os_build
= uts_buf
.release
;
425 processor_arch
= uts_buf
.machine
;
428 * The current windows host (win7) expects the build
429 * string to be of the form: x.y.z
430 * Strip additional information we may have.
432 p
= strchr(os_build
, '-');
436 file
= fopen("/etc/SuSE-release", "r");
438 goto kvp_osinfo_found
;
439 file
= fopen("/etc/redhat-release", "r");
441 goto kvp_osinfo_found
;
443 * Add code for other supported platforms.
447 * We don't have information about the os.
449 os_name
= uts_buf
.sysname
;
453 /* up to three lines */
454 p
= fgets(buf
, sizeof(buf
), file
);
456 p
= strchr(buf
, '\n');
465 p
= fgets(buf
, sizeof(buf
), file
);
467 p
= strchr(buf
, '\n');
476 p
= fgets(buf
, sizeof(buf
), file
);
478 p
= strchr(buf
, '\n');
493 static void kvp_process_ipconfig_file(char *cmd
,
494 char *config_buf
, int len
,
495 int element_size
, int offset
)
503 * First execute the command.
505 file
= popen(cmd
, "r");
510 memset(config_buf
, 0, len
);
511 while ((p
= fgets(buf
, sizeof(buf
), file
)) != NULL
) {
512 if ((len
- strlen(config_buf
)) < (element_size
+ 1))
517 strcat(config_buf
, p
);
518 strcat(config_buf
, ";");
523 static void kvp_get_ipconfig_info(char *if_name
,
524 struct hv_kvp_ipaddr_value
*buffer
)
529 * Get the address of default gateway (ipv4).
531 sprintf(cmd
, "%s %s", "ip route show dev", if_name
);
532 strcat(cmd
, " | awk '/default/ {print $3 }'");
535 * Execute the command to gather gateway info.
537 kvp_process_ipconfig_file(cmd
, (char *)buffer
->gate_way
,
538 (MAX_GATEWAY_SIZE
* 2), INET_ADDRSTRLEN
, 0);
541 * Get the address of default gateway (ipv6).
543 sprintf(cmd
, "%s %s", "ip -f inet6 route show dev", if_name
);
544 strcat(cmd
, " | awk '/default/ {print $3 }'");
547 * Execute the command to gather gateway info (ipv6).
549 kvp_process_ipconfig_file(cmd
, (char *)buffer
->gate_way
,
550 (MAX_GATEWAY_SIZE
* 2), INET6_ADDRSTRLEN
, 1);
555 static unsigned int hweight32(unsigned int *w
)
557 unsigned int res
= *w
- ((*w
>> 1) & 0x55555555);
558 res
= (res
& 0x33333333) + ((res
>> 2) & 0x33333333);
559 res
= (res
+ (res
>> 4)) & 0x0F0F0F0F;
560 res
= res
+ (res
>> 8);
561 return (res
+ (res
>> 16)) & 0x000000FF;
564 static int kvp_process_ip_address(void *addrp
,
565 int family
, char *buffer
,
566 int length
, int *offset
)
568 struct sockaddr_in
*addr
;
569 struct sockaddr_in6
*addr6
;
574 if (family
== AF_INET
) {
575 addr
= (struct sockaddr_in
*)addrp
;
576 str
= inet_ntop(family
, &addr
->sin_addr
, tmp
, 50);
577 addr_length
= INET_ADDRSTRLEN
;
579 addr6
= (struct sockaddr_in6
*)addrp
;
580 str
= inet_ntop(family
, &addr6
->sin6_addr
.s6_addr
, tmp
, 50);
581 addr_length
= INET6_ADDRSTRLEN
;
584 if ((length
- *offset
) < addr_length
+ 1)
587 strcpy(buffer
, "inet_ntop failed\n");
596 *offset
+= strlen(str
) + 1;
601 kvp_get_ip_address(int family
, char *if_name
, int op
,
602 void *out_buffer
, int length
)
604 struct ifaddrs
*ifap
;
605 struct ifaddrs
*curp
;
610 struct hv_kvp_ipaddr_value
*ip_buffer
;
611 char cidr_mask
[5]; /* /xyz */
616 struct sockaddr_in6
*addr6
;
618 if (op
== KVP_OP_ENUMERATE
) {
621 ip_buffer
= out_buffer
;
622 buffer
= (char *)ip_buffer
->ip_addr
;
623 ip_buffer
->addr_family
= 0;
626 * On entry into this function, the buffer is capable of holding the
630 if (getifaddrs(&ifap
)) {
631 strcpy(buffer
, "getifaddrs failed\n");
636 while (curp
!= NULL
) {
637 if (curp
->ifa_addr
== NULL
) {
638 curp
= curp
->ifa_next
;
642 if ((if_name
!= NULL
) &&
643 (strncmp(curp
->ifa_name
, if_name
, strlen(if_name
)))) {
645 * We want info about a specific interface;
648 curp
= curp
->ifa_next
;
653 * We only support two address families: AF_INET and AF_INET6.
654 * If a family value of 0 is specified, we collect both
655 * supported address families; if not we gather info on
656 * the specified address family.
658 if ((family
!= 0) && (curp
->ifa_addr
->sa_family
!= family
)) {
659 curp
= curp
->ifa_next
;
662 if ((curp
->ifa_addr
->sa_family
!= AF_INET
) &&
663 (curp
->ifa_addr
->sa_family
!= AF_INET6
)) {
664 curp
= curp
->ifa_next
;
668 if (op
== KVP_OP_GET_IP_INFO
) {
670 * Gather info other than the IP address.
671 * IP address info will be gathered later.
673 if (curp
->ifa_addr
->sa_family
== AF_INET
) {
674 ip_buffer
->addr_family
|= ADDR_FAMILY_IPV4
;
678 error
= kvp_process_ip_address(
688 ip_buffer
->addr_family
|= ADDR_FAMILY_IPV6
;
691 * Get subnet info in CIDR format.
694 sn_str
= (char *)ip_buffer
->sub_net
;
695 addr6
= (struct sockaddr_in6
*)
697 w
= addr6
->sin6_addr
.s6_addr32
;
699 for (i
= 0; i
< 4; i
++)
700 weight
+= hweight32(&w
[i
]);
702 sprintf(cidr_mask
, "/%d", weight
);
703 if ((length
- sn_offset
) <
704 (strlen(cidr_mask
) + 1))
708 strcpy(sn_str
, cidr_mask
);
710 strcat(sn_str
, cidr_mask
);
711 strcat((char *)ip_buffer
->sub_net
, ";");
712 sn_offset
+= strlen(sn_str
) + 1;
716 * Collect other ip related configuration info.
719 kvp_get_ipconfig_info(if_name
, ip_buffer
);
723 error
= kvp_process_ip_address(curp
->ifa_addr
,
724 curp
->ifa_addr
->sa_family
,
730 curp
= curp
->ifa_next
;
740 kvp_get_domain_name(char *buffer
, int length
)
742 struct addrinfo hints
, *info
;
745 gethostname(buffer
, length
);
746 memset(&hints
, 0, sizeof(hints
));
747 hints
.ai_family
= AF_INET
; /*Get only ipv4 addrinfo. */
748 hints
.ai_socktype
= SOCK_STREAM
;
749 hints
.ai_flags
= AI_CANONNAME
;
751 error
= getaddrinfo(buffer
, NULL
, &hints
, &info
);
753 strcpy(buffer
, "getaddrinfo failed\n");
756 strcpy(buffer
, info
->ai_canonname
);
762 netlink_send(int fd
, struct cn_msg
*msg
)
764 struct nlmsghdr
*nlh
;
766 struct msghdr message
;
770 size
= NLMSG_SPACE(sizeof(struct cn_msg
) + msg
->len
);
772 nlh
= (struct nlmsghdr
*)buffer
;
774 nlh
->nlmsg_pid
= getpid();
775 nlh
->nlmsg_type
= NLMSG_DONE
;
776 nlh
->nlmsg_len
= NLMSG_LENGTH(size
- sizeof(*nlh
));
777 nlh
->nlmsg_flags
= 0;
779 iov
[0].iov_base
= nlh
;
780 iov
[0].iov_len
= sizeof(*nlh
);
782 iov
[1].iov_base
= msg
;
783 iov
[1].iov_len
= size
;
785 memset(&message
, 0, sizeof(message
));
786 message
.msg_name
= &addr
;
787 message
.msg_namelen
= sizeof(addr
);
788 message
.msg_iov
= iov
;
789 message
.msg_iovlen
= 2;
791 return sendmsg(fd
, &message
, 0);
796 int fd
, len
, sock_opt
;
798 struct cn_msg
*message
;
800 struct nlmsghdr
*incoming_msg
;
801 struct cn_msg
*incoming_cn_msg
;
802 struct hv_kvp_msg
*hv_msg
;
810 openlog("KVP", 0, LOG_USER
);
811 syslog(LOG_INFO
, "KVP starting; pid is:%d", getpid());
813 * Retrieve OS release information.
817 if (kvp_file_init()) {
818 syslog(LOG_ERR
, "Failed to initialize the pools");
822 fd
= socket(AF_NETLINK
, SOCK_DGRAM
, NETLINK_CONNECTOR
);
824 syslog(LOG_ERR
, "netlink socket creation failed; error:%d", fd
);
827 addr
.nl_family
= AF_NETLINK
;
830 addr
.nl_groups
= CN_KVP_IDX
;
833 error
= bind(fd
, (struct sockaddr
*)&addr
, sizeof(addr
));
835 syslog(LOG_ERR
, "bind failed; error:%d", error
);
839 sock_opt
= addr
.nl_groups
;
840 setsockopt(fd
, 270, 1, &sock_opt
, sizeof(sock_opt
));
842 * Register ourselves with the kernel.
844 message
= (struct cn_msg
*)kvp_send_buffer
;
845 message
->id
.idx
= CN_KVP_IDX
;
846 message
->id
.val
= CN_KVP_VAL
;
848 hv_msg
= (struct hv_kvp_msg
*)message
->data
;
849 hv_msg
->kvp_hdr
.operation
= KVP_OP_REGISTER1
;
851 message
->len
= sizeof(struct hv_kvp_msg
);
853 len
= netlink_send(fd
, message
);
855 syslog(LOG_ERR
, "netlink_send failed; error:%d", len
);
863 struct sockaddr
*addr_p
= (struct sockaddr
*) &addr
;
864 socklen_t addr_l
= sizeof(addr
);
869 len
= recvfrom(fd
, kvp_recv_buffer
, sizeof(kvp_recv_buffer
), 0,
872 if (len
< 0 || addr
.nl_pid
) {
873 syslog(LOG_ERR
, "recvfrom failed; pid:%u error:%d %s",
874 addr
.nl_pid
, errno
, strerror(errno
));
879 incoming_msg
= (struct nlmsghdr
*)kvp_recv_buffer
;
880 incoming_cn_msg
= (struct cn_msg
*)NLMSG_DATA(incoming_msg
);
881 hv_msg
= (struct hv_kvp_msg
*)incoming_cn_msg
->data
;
884 * We will use the KVP header information to pass back
885 * the error from this daemon. So, first copy the state
886 * and set the error code to success.
888 op
= hv_msg
->kvp_hdr
.operation
;
889 pool
= hv_msg
->kvp_hdr
.pool
;
890 hv_msg
->error
= HV_S_OK
;
892 if ((in_hand_shake
) && (op
== KVP_OP_REGISTER1
)) {
894 * Driver is registering with us; stash away the version
898 p
= (char *)hv_msg
->body
.kvp_register
.version
;
899 lic_version
= malloc(strlen(p
) + 1);
901 strcpy(lic_version
, p
);
902 syslog(LOG_INFO
, "KVP LIC Version: %s",
905 syslog(LOG_ERR
, "malloc failed");
912 if (kvp_key_add_or_modify(pool
,
913 hv_msg
->body
.kvp_set
.data
.key
,
914 hv_msg
->body
.kvp_set
.data
.key_size
,
915 hv_msg
->body
.kvp_set
.data
.value
,
916 hv_msg
->body
.kvp_set
.data
.value_size
))
917 hv_msg
->error
= HV_S_CONT
;
921 if (kvp_get_value(pool
,
922 hv_msg
->body
.kvp_set
.data
.key
,
923 hv_msg
->body
.kvp_set
.data
.key_size
,
924 hv_msg
->body
.kvp_set
.data
.value
,
925 hv_msg
->body
.kvp_set
.data
.value_size
))
926 hv_msg
->error
= HV_S_CONT
;
930 if (kvp_key_delete(pool
,
931 hv_msg
->body
.kvp_delete
.key
,
932 hv_msg
->body
.kvp_delete
.key_size
))
933 hv_msg
->error
= HV_S_CONT
;
940 if (op
!= KVP_OP_ENUMERATE
)
944 * If the pool is KVP_POOL_AUTO, dynamically generate
945 * both the key and the value; if not read from the
948 if (pool
!= KVP_POOL_AUTO
) {
949 if (kvp_pool_enumerate(pool
,
950 hv_msg
->body
.kvp_enum_data
.index
,
951 hv_msg
->body
.kvp_enum_data
.data
.key
,
952 HV_KVP_EXCHANGE_MAX_KEY_SIZE
,
953 hv_msg
->body
.kvp_enum_data
.data
.value
,
954 HV_KVP_EXCHANGE_MAX_VALUE_SIZE
))
955 hv_msg
->error
= HV_S_CONT
;
959 hv_msg
= (struct hv_kvp_msg
*)incoming_cn_msg
->data
;
960 key_name
= (char *)hv_msg
->body
.kvp_enum_data
.data
.key
;
961 key_value
= (char *)hv_msg
->body
.kvp_enum_data
.data
.value
;
963 switch (hv_msg
->body
.kvp_enum_data
.index
) {
964 case FullyQualifiedDomainName
:
965 kvp_get_domain_name(key_value
,
966 HV_KVP_EXCHANGE_MAX_VALUE_SIZE
);
967 strcpy(key_name
, "FullyQualifiedDomainName");
969 case IntegrationServicesVersion
:
970 strcpy(key_name
, "IntegrationServicesVersion");
971 strcpy(key_value
, lic_version
);
973 case NetworkAddressIPv4
:
974 kvp_get_ip_address(AF_INET
, NULL
, KVP_OP_ENUMERATE
,
975 key_value
, HV_KVP_EXCHANGE_MAX_VALUE_SIZE
);
976 strcpy(key_name
, "NetworkAddressIPv4");
978 case NetworkAddressIPv6
:
979 kvp_get_ip_address(AF_INET6
, NULL
, KVP_OP_ENUMERATE
,
980 key_value
, HV_KVP_EXCHANGE_MAX_VALUE_SIZE
);
981 strcpy(key_name
, "NetworkAddressIPv6");
984 strcpy(key_value
, os_build
);
985 strcpy(key_name
, "OSBuildNumber");
988 strcpy(key_value
, os_name
);
989 strcpy(key_name
, "OSName");
992 strcpy(key_value
, os_major
);
993 strcpy(key_name
, "OSMajorVersion");
996 strcpy(key_value
, os_minor
);
997 strcpy(key_name
, "OSMinorVersion");
1000 strcpy(key_value
, os_build
);
1001 strcpy(key_name
, "OSVersion");
1003 case ProcessorArchitecture
:
1004 strcpy(key_value
, processor_arch
);
1005 strcpy(key_name
, "ProcessorArchitecture");
1008 hv_msg
->error
= HV_S_CONT
;
1012 * Send the value back to the kernel. The response is
1013 * already in the receive buffer. Update the cn_msg header to
1014 * reflect the key value that has been added to the message
1018 incoming_cn_msg
->id
.idx
= CN_KVP_IDX
;
1019 incoming_cn_msg
->id
.val
= CN_KVP_VAL
;
1020 incoming_cn_msg
->ack
= 0;
1021 incoming_cn_msg
->len
= sizeof(struct hv_kvp_msg
);
1023 len
= netlink_send(fd
, incoming_cn_msg
);
1025 syslog(LOG_ERR
, "net_link send failed; error:%d", len
);