Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 1 | /* |
| 2 | * An implementation of key value pair (KVP) functionality for Linux. |
| 3 | * |
| 4 | * |
| 5 | * Copyright (C) 2010, Novell, Inc. |
| 6 | * Author : K. Y. Srinivasan <ksrinivasan@novell.com> |
| 7 | * |
| 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. |
| 11 | * |
| 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 |
| 16 | * details. |
| 17 | * |
| 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. |
| 21 | * |
| 22 | */ |
| 23 | |
| 24 | |
| 25 | #include <sys/types.h> |
| 26 | #include <sys/socket.h> |
| 27 | #include <sys/poll.h> |
| 28 | #include <sys/utsname.h> |
| 29 | #include <linux/types.h> |
| 30 | #include <stdio.h> |
| 31 | #include <stdlib.h> |
| 32 | #include <unistd.h> |
| 33 | #include <string.h> |
| 34 | #include <errno.h> |
| 35 | #include <arpa/inet.h> |
| 36 | #include <linux/connector.h> |
K. Y. Srinivasan | eab6af7 | 2012-02-02 16:56:49 -0800 | [diff] [blame] | 37 | #include <linux/hyperv.h> |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 38 | #include <linux/netlink.h> |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 39 | #include <ifaddrs.h> |
| 40 | #include <netdb.h> |
| 41 | #include <syslog.h> |
K. Y. Srinivasan | db42533 | 2012-03-16 08:02:26 -0700 | [diff] [blame] | 42 | #include <sys/stat.h> |
| 43 | #include <fcntl.h> |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 44 | |
| 45 | /* |
| 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. |
| 51 | * |
| 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. |
| 54 | * |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 55 | */ |
| 56 | |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 57 | |
| 58 | enum key_index { |
| 59 | FullyQualifiedDomainName = 0, |
| 60 | IntegrationServicesVersion, /*This key is serviced in the kernel*/ |
| 61 | NetworkAddressIPv4, |
| 62 | NetworkAddressIPv6, |
| 63 | OSBuildNumber, |
| 64 | OSName, |
| 65 | OSMajorVersion, |
| 66 | OSMinorVersion, |
| 67 | OSVersion, |
| 68 | ProcessorArchitecture |
| 69 | }; |
| 70 | |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 71 | static char kvp_send_buffer[4096]; |
K. Y. Srinivasan | 9b59578 | 2012-08-13 10:06:51 -0700 | [diff] [blame] | 72 | static char kvp_recv_buffer[4096 * 2]; |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 73 | static struct sockaddr_nl addr; |
K. Y. Srinivasan | b47a81d | 2012-08-13 10:06:52 -0700 | [diff] [blame] | 74 | static int in_hand_shake = 1; |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 75 | |
Olaf Hering | 7989f7d | 2011-03-22 10:02:17 +0100 | [diff] [blame] | 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; |
K. Y. Srinivasan | b47a81d | 2012-08-13 10:06:52 -0700 | [diff] [blame] | 81 | static char *lic_version = "Unknown version"; |
Olaf Hering | 7989f7d | 2011-03-22 10:02:17 +0100 | [diff] [blame] | 82 | static struct utsname uts_buf; |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 83 | |
K. Y. Srinivasan | db42533 | 2012-03-16 08:02:26 -0700 | [diff] [blame] | 84 | |
| 85 | #define MAX_FILE_NAME 100 |
| 86 | #define ENTRIES_PER_BLOCK 50 |
| 87 | |
| 88 | struct kvp_record { |
| 89 | __u8 key[HV_KVP_EXCHANGE_MAX_KEY_SIZE]; |
| 90 | __u8 value[HV_KVP_EXCHANGE_MAX_VALUE_SIZE]; |
| 91 | }; |
| 92 | |
| 93 | struct kvp_file_state { |
| 94 | int fd; |
| 95 | int num_blocks; |
| 96 | struct kvp_record *records; |
| 97 | int num_records; |
| 98 | __u8 fname[MAX_FILE_NAME]; |
| 99 | }; |
| 100 | |
| 101 | static struct kvp_file_state kvp_file_info[KVP_POOL_COUNT]; |
| 102 | |
| 103 | static void kvp_acquire_lock(int pool) |
| 104 | { |
| 105 | struct flock fl = {F_WRLCK, SEEK_SET, 0, 0, 0}; |
| 106 | fl.l_pid = getpid(); |
| 107 | |
| 108 | if (fcntl(kvp_file_info[pool].fd, F_SETLKW, &fl) == -1) { |
| 109 | syslog(LOG_ERR, "Failed to acquire the lock pool: %d", pool); |
| 110 | exit(-1); |
| 111 | } |
| 112 | } |
| 113 | |
| 114 | static void kvp_release_lock(int pool) |
| 115 | { |
| 116 | struct flock fl = {F_UNLCK, SEEK_SET, 0, 0, 0}; |
| 117 | fl.l_pid = getpid(); |
| 118 | |
| 119 | if (fcntl(kvp_file_info[pool].fd, F_SETLK, &fl) == -1) { |
| 120 | perror("fcntl"); |
| 121 | syslog(LOG_ERR, "Failed to release the lock pool: %d", pool); |
| 122 | exit(-1); |
| 123 | } |
| 124 | } |
| 125 | |
| 126 | static void kvp_update_file(int pool) |
| 127 | { |
| 128 | FILE *filep; |
| 129 | size_t bytes_written; |
| 130 | |
| 131 | /* |
| 132 | * We are going to write our in-memory registry out to |
| 133 | * disk; acquire the lock first. |
| 134 | */ |
| 135 | kvp_acquire_lock(pool); |
| 136 | |
| 137 | filep = fopen(kvp_file_info[pool].fname, "w"); |
| 138 | if (!filep) { |
| 139 | kvp_release_lock(pool); |
| 140 | syslog(LOG_ERR, "Failed to open file, pool: %d", pool); |
| 141 | exit(-1); |
| 142 | } |
| 143 | |
| 144 | bytes_written = fwrite(kvp_file_info[pool].records, |
| 145 | sizeof(struct kvp_record), |
| 146 | kvp_file_info[pool].num_records, filep); |
| 147 | |
| 148 | fflush(filep); |
| 149 | kvp_release_lock(pool); |
| 150 | } |
| 151 | |
K. Y. Srinivasan | adc80ae | 2012-03-16 08:02:27 -0700 | [diff] [blame] | 152 | static void kvp_update_mem_state(int pool) |
| 153 | { |
| 154 | FILE *filep; |
| 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; |
| 160 | |
| 161 | kvp_acquire_lock(pool); |
| 162 | |
| 163 | filep = fopen(kvp_file_info[pool].fname, "r"); |
| 164 | if (!filep) { |
| 165 | kvp_release_lock(pool); |
| 166 | syslog(LOG_ERR, "Failed to open file, pool: %d", pool); |
| 167 | exit(-1); |
| 168 | } |
| 169 | while (!feof(filep)) { |
| 170 | readp = &record[records_read]; |
| 171 | records_read += fread(readp, sizeof(struct kvp_record), |
| 172 | ENTRIES_PER_BLOCK * num_blocks, |
| 173 | filep); |
| 174 | |
| 175 | if (!feof(filep)) { |
| 176 | /* |
| 177 | * We have more data to read. |
| 178 | */ |
| 179 | num_blocks++; |
| 180 | record = realloc(record, alloc_unit * num_blocks); |
| 181 | |
| 182 | if (record == NULL) { |
| 183 | syslog(LOG_ERR, "malloc failed"); |
| 184 | exit(-1); |
| 185 | } |
| 186 | continue; |
| 187 | } |
| 188 | break; |
| 189 | } |
| 190 | |
| 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; |
| 194 | |
| 195 | kvp_release_lock(pool); |
| 196 | } |
K. Y. Srinivasan | db42533 | 2012-03-16 08:02:26 -0700 | [diff] [blame] | 197 | static int kvp_file_init(void) |
| 198 | { |
| 199 | int ret, fd; |
| 200 | FILE *filep; |
| 201 | size_t records_read; |
| 202 | __u8 *fname; |
| 203 | struct kvp_record *record; |
| 204 | struct kvp_record *readp; |
| 205 | int num_blocks; |
| 206 | int i; |
| 207 | int alloc_unit = sizeof(struct kvp_record) * ENTRIES_PER_BLOCK; |
| 208 | |
| 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"); |
| 212 | exit(-1); |
| 213 | } |
| 214 | } |
| 215 | |
| 216 | for (i = 0; i < KVP_POOL_COUNT; i++) { |
| 217 | fname = kvp_file_info[i].fname; |
| 218 | records_read = 0; |
| 219 | num_blocks = 1; |
| 220 | sprintf(fname, "/var/opt/hyperv/.kvp_pool_%d", i); |
| 221 | fd = open(fname, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR | S_IROTH); |
| 222 | |
| 223 | if (fd == -1) |
| 224 | return 1; |
| 225 | |
| 226 | |
| 227 | filep = fopen(fname, "r"); |
| 228 | if (!filep) |
| 229 | return 1; |
| 230 | |
| 231 | record = malloc(alloc_unit * num_blocks); |
| 232 | if (record == NULL) { |
| 233 | fclose(filep); |
| 234 | return 1; |
| 235 | } |
| 236 | while (!feof(filep)) { |
| 237 | readp = &record[records_read]; |
| 238 | records_read += fread(readp, sizeof(struct kvp_record), |
| 239 | ENTRIES_PER_BLOCK, |
| 240 | filep); |
| 241 | |
| 242 | if (!feof(filep)) { |
| 243 | /* |
| 244 | * We have more data to read. |
| 245 | */ |
| 246 | num_blocks++; |
| 247 | record = realloc(record, alloc_unit * |
| 248 | num_blocks); |
| 249 | if (record == NULL) { |
| 250 | fclose(filep); |
| 251 | return 1; |
| 252 | } |
| 253 | continue; |
| 254 | } |
| 255 | break; |
| 256 | } |
| 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; |
| 261 | fclose(filep); |
| 262 | |
| 263 | } |
| 264 | |
| 265 | return 0; |
| 266 | } |
| 267 | |
| 268 | static int kvp_key_delete(int pool, __u8 *key, int key_size) |
| 269 | { |
| 270 | int i; |
| 271 | int j, k; |
K. Y. Srinivasan | adc80ae | 2012-03-16 08:02:27 -0700 | [diff] [blame] | 272 | int num_records; |
| 273 | struct kvp_record *record; |
| 274 | |
| 275 | /* |
| 276 | * First update the in-memory state. |
| 277 | */ |
| 278 | kvp_update_mem_state(pool); |
| 279 | |
| 280 | num_records = kvp_file_info[pool].num_records; |
| 281 | record = kvp_file_info[pool].records; |
K. Y. Srinivasan | db42533 | 2012-03-16 08:02:26 -0700 | [diff] [blame] | 282 | |
| 283 | for (i = 0; i < num_records; i++) { |
| 284 | if (memcmp(key, record[i].key, key_size)) |
| 285 | continue; |
| 286 | /* |
| 287 | * Found a match; just move the remaining |
| 288 | * entries up. |
| 289 | */ |
| 290 | if (i == num_records) { |
| 291 | kvp_file_info[pool].num_records--; |
| 292 | kvp_update_file(pool); |
| 293 | return 0; |
| 294 | } |
| 295 | |
| 296 | j = i; |
| 297 | k = j + 1; |
| 298 | for (; k < num_records; k++) { |
| 299 | strcpy(record[j].key, record[k].key); |
| 300 | strcpy(record[j].value, record[k].value); |
| 301 | j++; |
| 302 | } |
| 303 | |
| 304 | kvp_file_info[pool].num_records--; |
| 305 | kvp_update_file(pool); |
| 306 | return 0; |
| 307 | } |
| 308 | return 1; |
| 309 | } |
| 310 | |
| 311 | static int kvp_key_add_or_modify(int pool, __u8 *key, int key_size, __u8 *value, |
| 312 | int value_size) |
| 313 | { |
| 314 | int i; |
| 315 | int j, k; |
K. Y. Srinivasan | adc80ae | 2012-03-16 08:02:27 -0700 | [diff] [blame] | 316 | int num_records; |
| 317 | struct kvp_record *record; |
| 318 | int num_blocks; |
K. Y. Srinivasan | db42533 | 2012-03-16 08:02:26 -0700 | [diff] [blame] | 319 | |
| 320 | if ((key_size > HV_KVP_EXCHANGE_MAX_KEY_SIZE) || |
| 321 | (value_size > HV_KVP_EXCHANGE_MAX_VALUE_SIZE)) |
| 322 | return 1; |
| 323 | |
K. Y. Srinivasan | adc80ae | 2012-03-16 08:02:27 -0700 | [diff] [blame] | 324 | /* |
| 325 | * First update the in-memory state. |
| 326 | */ |
| 327 | kvp_update_mem_state(pool); |
| 328 | |
| 329 | num_records = kvp_file_info[pool].num_records; |
| 330 | record = kvp_file_info[pool].records; |
| 331 | num_blocks = kvp_file_info[pool].num_blocks; |
| 332 | |
K. Y. Srinivasan | db42533 | 2012-03-16 08:02:26 -0700 | [diff] [blame] | 333 | for (i = 0; i < num_records; i++) { |
| 334 | if (memcmp(key, record[i].key, key_size)) |
| 335 | continue; |
| 336 | /* |
| 337 | * Found a match; just update the value - |
| 338 | * this is the modify case. |
| 339 | */ |
| 340 | memcpy(record[i].value, value, value_size); |
| 341 | kvp_update_file(pool); |
| 342 | return 0; |
| 343 | } |
| 344 | |
| 345 | /* |
| 346 | * Need to add a new entry; |
| 347 | */ |
| 348 | if (num_records == (ENTRIES_PER_BLOCK * num_blocks)) { |
| 349 | /* Need to allocate a larger array for reg entries. */ |
| 350 | record = realloc(record, sizeof(struct kvp_record) * |
| 351 | ENTRIES_PER_BLOCK * (num_blocks + 1)); |
| 352 | |
| 353 | if (record == NULL) |
| 354 | return 1; |
| 355 | kvp_file_info[pool].num_blocks++; |
| 356 | |
| 357 | } |
| 358 | memcpy(record[i].value, value, value_size); |
| 359 | memcpy(record[i].key, key, key_size); |
| 360 | kvp_file_info[pool].records = record; |
| 361 | kvp_file_info[pool].num_records++; |
| 362 | kvp_update_file(pool); |
| 363 | return 0; |
| 364 | } |
| 365 | |
| 366 | static int kvp_get_value(int pool, __u8 *key, int key_size, __u8 *value, |
| 367 | int value_size) |
| 368 | { |
| 369 | int i; |
K. Y. Srinivasan | adc80ae | 2012-03-16 08:02:27 -0700 | [diff] [blame] | 370 | int num_records; |
| 371 | struct kvp_record *record; |
K. Y. Srinivasan | db42533 | 2012-03-16 08:02:26 -0700 | [diff] [blame] | 372 | |
| 373 | if ((key_size > HV_KVP_EXCHANGE_MAX_KEY_SIZE) || |
| 374 | (value_size > HV_KVP_EXCHANGE_MAX_VALUE_SIZE)) |
| 375 | return 1; |
| 376 | |
K. Y. Srinivasan | adc80ae | 2012-03-16 08:02:27 -0700 | [diff] [blame] | 377 | /* |
| 378 | * First update the in-memory state. |
| 379 | */ |
| 380 | kvp_update_mem_state(pool); |
| 381 | |
| 382 | num_records = kvp_file_info[pool].num_records; |
| 383 | record = kvp_file_info[pool].records; |
| 384 | |
K. Y. Srinivasan | db42533 | 2012-03-16 08:02:26 -0700 | [diff] [blame] | 385 | for (i = 0; i < num_records; i++) { |
| 386 | if (memcmp(key, record[i].key, key_size)) |
| 387 | continue; |
| 388 | /* |
| 389 | * Found a match; just copy the value out. |
| 390 | */ |
| 391 | memcpy(value, record[i].value, value_size); |
| 392 | return 0; |
| 393 | } |
| 394 | |
| 395 | return 1; |
| 396 | } |
| 397 | |
K. Y. Srinivasan | b47a81d | 2012-08-13 10:06:52 -0700 | [diff] [blame] | 398 | static int kvp_pool_enumerate(int pool, int index, __u8 *key, int key_size, |
K. Y. Srinivasan | adc80ae | 2012-03-16 08:02:27 -0700 | [diff] [blame] | 399 | __u8 *value, int value_size) |
| 400 | { |
| 401 | struct kvp_record *record; |
| 402 | |
| 403 | /* |
| 404 | * First update our in-memory database. |
| 405 | */ |
| 406 | kvp_update_mem_state(pool); |
| 407 | record = kvp_file_info[pool].records; |
| 408 | |
| 409 | if (index >= kvp_file_info[pool].num_records) { |
K. Y. Srinivasan | b47a81d | 2012-08-13 10:06:52 -0700 | [diff] [blame] | 410 | return 1; |
K. Y. Srinivasan | adc80ae | 2012-03-16 08:02:27 -0700 | [diff] [blame] | 411 | } |
| 412 | |
| 413 | memcpy(key, record[index].key, key_size); |
| 414 | memcpy(value, record[index].value, value_size); |
K. Y. Srinivasan | b47a81d | 2012-08-13 10:06:52 -0700 | [diff] [blame] | 415 | return 0; |
K. Y. Srinivasan | adc80ae | 2012-03-16 08:02:27 -0700 | [diff] [blame] | 416 | } |
| 417 | |
| 418 | |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 419 | void kvp_get_os_info(void) |
| 420 | { |
| 421 | FILE *file; |
Olaf Hering | 7989f7d | 2011-03-22 10:02:17 +0100 | [diff] [blame] | 422 | char *p, buf[512]; |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 423 | |
Olaf Hering | 7989f7d | 2011-03-22 10:02:17 +0100 | [diff] [blame] | 424 | uname(&uts_buf); |
| 425 | os_build = uts_buf.release; |
K. Y. Srinivasan | 064931d | 2011-07-19 11:44:20 -0700 | [diff] [blame] | 426 | processor_arch = uts_buf.machine; |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 427 | |
K. Y. Srinivasan | e54bbc6 | 2011-07-22 10:14:31 -0700 | [diff] [blame] | 428 | /* |
| 429 | * The current windows host (win7) expects the build |
| 430 | * string to be of the form: x.y.z |
| 431 | * Strip additional information we may have. |
| 432 | */ |
| 433 | p = strchr(os_build, '-'); |
| 434 | if (p) |
| 435 | *p = '\0'; |
| 436 | |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 437 | file = fopen("/etc/SuSE-release", "r"); |
| 438 | if (file != NULL) |
| 439 | goto kvp_osinfo_found; |
| 440 | file = fopen("/etc/redhat-release", "r"); |
| 441 | if (file != NULL) |
| 442 | goto kvp_osinfo_found; |
| 443 | /* |
| 444 | * Add code for other supported platforms. |
| 445 | */ |
| 446 | |
| 447 | /* |
| 448 | * We don't have information about the os. |
| 449 | */ |
Olaf Hering | 7989f7d | 2011-03-22 10:02:17 +0100 | [diff] [blame] | 450 | os_name = uts_buf.sysname; |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 451 | return; |
| 452 | |
| 453 | kvp_osinfo_found: |
Olaf Hering | 7989f7d | 2011-03-22 10:02:17 +0100 | [diff] [blame] | 454 | /* up to three lines */ |
| 455 | p = fgets(buf, sizeof(buf), file); |
| 456 | if (p) { |
| 457 | p = strchr(buf, '\n'); |
| 458 | if (p) |
| 459 | *p = '\0'; |
| 460 | p = strdup(buf); |
| 461 | if (!p) |
| 462 | goto done; |
| 463 | os_name = p; |
| 464 | |
| 465 | /* second line */ |
| 466 | p = fgets(buf, sizeof(buf), file); |
| 467 | if (p) { |
| 468 | p = strchr(buf, '\n'); |
| 469 | if (p) |
| 470 | *p = '\0'; |
| 471 | p = strdup(buf); |
| 472 | if (!p) |
| 473 | goto done; |
| 474 | os_major = p; |
| 475 | |
| 476 | /* third line */ |
| 477 | p = fgets(buf, sizeof(buf), file); |
| 478 | if (p) { |
| 479 | p = strchr(buf, '\n'); |
| 480 | if (p) |
| 481 | *p = '\0'; |
| 482 | p = strdup(buf); |
| 483 | if (p) |
| 484 | os_minor = p; |
| 485 | } |
| 486 | } |
| 487 | } |
| 488 | |
| 489 | done: |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 490 | fclose(file); |
| 491 | return; |
| 492 | } |
| 493 | |
K. Y. Srinivasan | af73301 | 2012-08-16 18:32:14 -0700 | [diff] [blame] | 494 | static int kvp_process_ip_address(void *addrp, |
| 495 | int family, char *buffer, |
| 496 | int length, int *offset) |
| 497 | { |
| 498 | struct sockaddr_in *addr; |
| 499 | struct sockaddr_in6 *addr6; |
| 500 | int addr_length; |
| 501 | char tmp[50]; |
| 502 | const char *str; |
| 503 | |
| 504 | if (family == AF_INET) { |
| 505 | addr = (struct sockaddr_in *)addrp; |
| 506 | str = inet_ntop(family, &addr->sin_addr, tmp, 50); |
| 507 | addr_length = INET_ADDRSTRLEN; |
| 508 | } else { |
| 509 | addr6 = (struct sockaddr_in6 *)addrp; |
| 510 | str = inet_ntop(family, &addr6->sin6_addr.s6_addr, tmp, 50); |
| 511 | addr_length = INET6_ADDRSTRLEN; |
| 512 | } |
| 513 | |
| 514 | if ((length - *offset) < addr_length + 1) |
| 515 | return 1; |
| 516 | if (str == NULL) { |
| 517 | strcpy(buffer, "inet_ntop failed\n"); |
| 518 | return 1; |
| 519 | } |
| 520 | if (*offset == 0) |
| 521 | strcpy(buffer, tmp); |
| 522 | else |
| 523 | strcat(buffer, tmp); |
| 524 | strcat(buffer, ";"); |
| 525 | |
| 526 | *offset += strlen(str) + 1; |
| 527 | return 0; |
| 528 | } |
| 529 | |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 530 | static int |
K. Y. Srinivasan | 0ecaa19 | 2012-08-16 18:32:13 -0700 | [diff] [blame] | 531 | kvp_get_ip_address(int family, char *if_name, int op, |
| 532 | void *out_buffer, int length) |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 533 | { |
| 534 | struct ifaddrs *ifap; |
| 535 | struct ifaddrs *curp; |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 536 | int offset = 0; |
| 537 | const char *str; |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 538 | int error = 0; |
K. Y. Srinivasan | 0ecaa19 | 2012-08-16 18:32:13 -0700 | [diff] [blame] | 539 | char *buffer; |
| 540 | struct hv_kvp_ipaddr_value *ip_buffer; |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 541 | |
K. Y. Srinivasan | 0ecaa19 | 2012-08-16 18:32:13 -0700 | [diff] [blame] | 542 | if (op == KVP_OP_ENUMERATE) { |
| 543 | buffer = out_buffer; |
| 544 | } else { |
| 545 | ip_buffer = out_buffer; |
| 546 | buffer = (char *)ip_buffer->ip_addr; |
| 547 | ip_buffer->addr_family = 0; |
| 548 | } |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 549 | /* |
| 550 | * On entry into this function, the buffer is capable of holding the |
K. Y. Srinivasan | 0ecaa19 | 2012-08-16 18:32:13 -0700 | [diff] [blame] | 551 | * maximum key value. |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 552 | */ |
| 553 | |
| 554 | if (getifaddrs(&ifap)) { |
| 555 | strcpy(buffer, "getifaddrs failed\n"); |
| 556 | return 1; |
| 557 | } |
| 558 | |
| 559 | curp = ifap; |
| 560 | while (curp != NULL) { |
K. Y. Srinivasan | 0ecaa19 | 2012-08-16 18:32:13 -0700 | [diff] [blame] | 561 | if (curp->ifa_addr == NULL) { |
| 562 | curp = curp->ifa_next; |
| 563 | continue; |
| 564 | } |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 565 | |
K. Y. Srinivasan | 0ecaa19 | 2012-08-16 18:32:13 -0700 | [diff] [blame] | 566 | if ((if_name != NULL) && |
| 567 | (strncmp(curp->ifa_name, if_name, strlen(if_name)))) { |
| 568 | /* |
| 569 | * We want info about a specific interface; |
| 570 | * just continue. |
| 571 | */ |
| 572 | curp = curp->ifa_next; |
| 573 | continue; |
| 574 | } |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 575 | |
K. Y. Srinivasan | 0ecaa19 | 2012-08-16 18:32:13 -0700 | [diff] [blame] | 576 | /* |
| 577 | * We only support two address families: AF_INET and AF_INET6. |
| 578 | * If a family value of 0 is specified, we collect both |
| 579 | * supported address families; if not we gather info on |
| 580 | * the specified address family. |
| 581 | */ |
| 582 | if ((family != 0) && (curp->ifa_addr->sa_family != family)) { |
| 583 | curp = curp->ifa_next; |
| 584 | continue; |
| 585 | } |
| 586 | if ((curp->ifa_addr->sa_family != AF_INET) && |
| 587 | (curp->ifa_addr->sa_family != AF_INET6)) { |
| 588 | curp = curp->ifa_next; |
| 589 | continue; |
| 590 | } |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 591 | |
K. Y. Srinivasan | 0d5b6b1 | 2012-08-16 18:32:15 -0700 | [diff] [blame^] | 592 | if (op == KVP_OP_GET_IP_INFO) { |
| 593 | /* |
| 594 | * Gather info other than the IP address. |
| 595 | * IP address info will be gathered later. |
| 596 | */ |
| 597 | if (curp->ifa_addr->sa_family == AF_INET) |
| 598 | ip_buffer->addr_family |= ADDR_FAMILY_IPV4; |
| 599 | else |
| 600 | ip_buffer->addr_family |= ADDR_FAMILY_IPV6; |
| 601 | } |
| 602 | |
K. Y. Srinivasan | af73301 | 2012-08-16 18:32:14 -0700 | [diff] [blame] | 603 | error = kvp_process_ip_address(curp->ifa_addr, |
| 604 | curp->ifa_addr->sa_family, |
| 605 | buffer, |
| 606 | length, &offset); |
| 607 | if (error) |
| 608 | goto getaddr_done; |
K. Y. Srinivasan | 0ecaa19 | 2012-08-16 18:32:13 -0700 | [diff] [blame] | 609 | |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 610 | curp = curp->ifa_next; |
| 611 | } |
| 612 | |
| 613 | getaddr_done: |
| 614 | freeifaddrs(ifap); |
| 615 | return error; |
| 616 | } |
| 617 | |
| 618 | |
| 619 | static int |
| 620 | kvp_get_domain_name(char *buffer, int length) |
| 621 | { |
| 622 | struct addrinfo hints, *info ; |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 623 | int error = 0; |
| 624 | |
K. Y. Srinivasan | 5be528c | 2011-07-26 11:03:10 -0700 | [diff] [blame] | 625 | gethostname(buffer, length); |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 626 | memset(&hints, 0, sizeof(hints)); |
| 627 | hints.ai_family = AF_INET; /*Get only ipv4 addrinfo. */ |
| 628 | hints.ai_socktype = SOCK_STREAM; |
| 629 | hints.ai_flags = AI_CANONNAME; |
| 630 | |
K. Y. Srinivasan | 5be528c | 2011-07-26 11:03:10 -0700 | [diff] [blame] | 631 | error = getaddrinfo(buffer, NULL, &hints, &info); |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 632 | if (error != 0) { |
| 633 | strcpy(buffer, "getaddrinfo failed\n"); |
K. Y. Srinivasan | 5be528c | 2011-07-26 11:03:10 -0700 | [diff] [blame] | 634 | return error; |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 635 | } |
| 636 | strcpy(buffer, info->ai_canonname); |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 637 | freeaddrinfo(info); |
| 638 | return error; |
| 639 | } |
| 640 | |
| 641 | static int |
| 642 | netlink_send(int fd, struct cn_msg *msg) |
| 643 | { |
| 644 | struct nlmsghdr *nlh; |
| 645 | unsigned int size; |
| 646 | struct msghdr message; |
| 647 | char buffer[64]; |
| 648 | struct iovec iov[2]; |
| 649 | |
| 650 | size = NLMSG_SPACE(sizeof(struct cn_msg) + msg->len); |
| 651 | |
| 652 | nlh = (struct nlmsghdr *)buffer; |
| 653 | nlh->nlmsg_seq = 0; |
| 654 | nlh->nlmsg_pid = getpid(); |
| 655 | nlh->nlmsg_type = NLMSG_DONE; |
| 656 | nlh->nlmsg_len = NLMSG_LENGTH(size - sizeof(*nlh)); |
| 657 | nlh->nlmsg_flags = 0; |
| 658 | |
| 659 | iov[0].iov_base = nlh; |
| 660 | iov[0].iov_len = sizeof(*nlh); |
| 661 | |
| 662 | iov[1].iov_base = msg; |
| 663 | iov[1].iov_len = size; |
| 664 | |
| 665 | memset(&message, 0, sizeof(message)); |
| 666 | message.msg_name = &addr; |
| 667 | message.msg_namelen = sizeof(addr); |
| 668 | message.msg_iov = iov; |
| 669 | message.msg_iovlen = 2; |
| 670 | |
| 671 | return sendmsg(fd, &message, 0); |
| 672 | } |
| 673 | |
Olaf Hering | 7989f7d | 2011-03-22 10:02:17 +0100 | [diff] [blame] | 674 | int main(void) |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 675 | { |
| 676 | int fd, len, sock_opt; |
| 677 | int error; |
| 678 | struct cn_msg *message; |
| 679 | struct pollfd pfd; |
| 680 | struct nlmsghdr *incoming_msg; |
| 681 | struct cn_msg *incoming_cn_msg; |
K. Y. Srinivasan | 264033543 | 2012-02-02 16:56:50 -0800 | [diff] [blame] | 682 | struct hv_kvp_msg *hv_msg; |
Olaf Hering | 7989f7d | 2011-03-22 10:02:17 +0100 | [diff] [blame] | 683 | char *p; |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 684 | char *key_value; |
| 685 | char *key_name; |
K. Y. Srinivasan | b47a81d | 2012-08-13 10:06:52 -0700 | [diff] [blame] | 686 | int op; |
| 687 | int pool; |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 688 | |
| 689 | daemon(1, 0); |
| 690 | openlog("KVP", 0, LOG_USER); |
| 691 | syslog(LOG_INFO, "KVP starting; pid is:%d", getpid()); |
| 692 | /* |
| 693 | * Retrieve OS release information. |
| 694 | */ |
| 695 | kvp_get_os_info(); |
| 696 | |
K. Y. Srinivasan | db42533 | 2012-03-16 08:02:26 -0700 | [diff] [blame] | 697 | if (kvp_file_init()) { |
| 698 | syslog(LOG_ERR, "Failed to initialize the pools"); |
| 699 | exit(-1); |
| 700 | } |
| 701 | |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 702 | fd = socket(AF_NETLINK, SOCK_DGRAM, NETLINK_CONNECTOR); |
| 703 | if (fd < 0) { |
| 704 | syslog(LOG_ERR, "netlink socket creation failed; error:%d", fd); |
| 705 | exit(-1); |
| 706 | } |
| 707 | addr.nl_family = AF_NETLINK; |
| 708 | addr.nl_pad = 0; |
| 709 | addr.nl_pid = 0; |
| 710 | addr.nl_groups = CN_KVP_IDX; |
| 711 | |
| 712 | |
| 713 | error = bind(fd, (struct sockaddr *)&addr, sizeof(addr)); |
| 714 | if (error < 0) { |
| 715 | syslog(LOG_ERR, "bind failed; error:%d", error); |
| 716 | close(fd); |
| 717 | exit(-1); |
| 718 | } |
| 719 | sock_opt = addr.nl_groups; |
| 720 | setsockopt(fd, 270, 1, &sock_opt, sizeof(sock_opt)); |
| 721 | /* |
| 722 | * Register ourselves with the kernel. |
| 723 | */ |
| 724 | message = (struct cn_msg *)kvp_send_buffer; |
| 725 | message->id.idx = CN_KVP_IDX; |
| 726 | message->id.val = CN_KVP_VAL; |
K. Y. Srinivasan | 264033543 | 2012-02-02 16:56:50 -0800 | [diff] [blame] | 727 | |
| 728 | hv_msg = (struct hv_kvp_msg *)message->data; |
K. Y. Srinivasan | b47a81d | 2012-08-13 10:06:52 -0700 | [diff] [blame] | 729 | hv_msg->kvp_hdr.operation = KVP_OP_REGISTER1; |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 730 | message->ack = 0; |
K. Y. Srinivasan | 264033543 | 2012-02-02 16:56:50 -0800 | [diff] [blame] | 731 | message->len = sizeof(struct hv_kvp_msg); |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 732 | |
| 733 | len = netlink_send(fd, message); |
| 734 | if (len < 0) { |
| 735 | syslog(LOG_ERR, "netlink_send failed; error:%d", len); |
| 736 | close(fd); |
| 737 | exit(-1); |
| 738 | } |
| 739 | |
| 740 | pfd.fd = fd; |
| 741 | |
| 742 | while (1) { |
Olaf Hering | bcc2c9c | 2012-05-31 16:40:06 +0200 | [diff] [blame] | 743 | struct sockaddr *addr_p = (struct sockaddr *) &addr; |
| 744 | socklen_t addr_l = sizeof(addr); |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 745 | pfd.events = POLLIN; |
| 746 | pfd.revents = 0; |
| 747 | poll(&pfd, 1, -1); |
| 748 | |
Olaf Hering | bcc2c9c | 2012-05-31 16:40:06 +0200 | [diff] [blame] | 749 | len = recvfrom(fd, kvp_recv_buffer, sizeof(kvp_recv_buffer), 0, |
| 750 | addr_p, &addr_l); |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 751 | |
Olaf Hering | bcc2c9c | 2012-05-31 16:40:06 +0200 | [diff] [blame] | 752 | if (len < 0 || addr.nl_pid) { |
| 753 | syslog(LOG_ERR, "recvfrom failed; pid:%u error:%d %s", |
| 754 | addr.nl_pid, errno, strerror(errno)); |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 755 | close(fd); |
| 756 | return -1; |
| 757 | } |
| 758 | |
| 759 | incoming_msg = (struct nlmsghdr *)kvp_recv_buffer; |
| 760 | incoming_cn_msg = (struct cn_msg *)NLMSG_DATA(incoming_msg); |
K. Y. Srinivasan | 264033543 | 2012-02-02 16:56:50 -0800 | [diff] [blame] | 761 | hv_msg = (struct hv_kvp_msg *)incoming_cn_msg->data; |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 762 | |
K. Y. Srinivasan | b47a81d | 2012-08-13 10:06:52 -0700 | [diff] [blame] | 763 | /* |
| 764 | * We will use the KVP header information to pass back |
| 765 | * the error from this daemon. So, first copy the state |
| 766 | * and set the error code to success. |
| 767 | */ |
| 768 | op = hv_msg->kvp_hdr.operation; |
| 769 | pool = hv_msg->kvp_hdr.pool; |
| 770 | hv_msg->error = HV_S_OK; |
| 771 | |
| 772 | if ((in_hand_shake) && (op == KVP_OP_REGISTER1)) { |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 773 | /* |
| 774 | * Driver is registering with us; stash away the version |
| 775 | * information. |
| 776 | */ |
K. Y. Srinivasan | b47a81d | 2012-08-13 10:06:52 -0700 | [diff] [blame] | 777 | in_hand_shake = 0; |
K. Y. Srinivasan | e485ceac | 2012-03-10 15:32:08 -0800 | [diff] [blame] | 778 | p = (char *)hv_msg->body.kvp_register.version; |
Olaf Hering | 7989f7d | 2011-03-22 10:02:17 +0100 | [diff] [blame] | 779 | lic_version = malloc(strlen(p) + 1); |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 780 | if (lic_version) { |
Olaf Hering | 7989f7d | 2011-03-22 10:02:17 +0100 | [diff] [blame] | 781 | strcpy(lic_version, p); |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 782 | syslog(LOG_INFO, "KVP LIC Version: %s", |
| 783 | lic_version); |
| 784 | } else { |
| 785 | syslog(LOG_ERR, "malloc failed"); |
| 786 | } |
| 787 | continue; |
K. Y. Srinivasan | b47a81d | 2012-08-13 10:06:52 -0700 | [diff] [blame] | 788 | } |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 789 | |
K. Y. Srinivasan | b47a81d | 2012-08-13 10:06:52 -0700 | [diff] [blame] | 790 | switch (op) { |
K. Y. Srinivasan | fa3d5b8 | 2012-03-16 08:02:25 -0700 | [diff] [blame] | 791 | case KVP_OP_SET: |
K. Y. Srinivasan | b47a81d | 2012-08-13 10:06:52 -0700 | [diff] [blame] | 792 | if (kvp_key_add_or_modify(pool, |
K. Y. Srinivasan | db42533 | 2012-03-16 08:02:26 -0700 | [diff] [blame] | 793 | hv_msg->body.kvp_set.data.key, |
| 794 | hv_msg->body.kvp_set.data.key_size, |
| 795 | hv_msg->body.kvp_set.data.value, |
| 796 | hv_msg->body.kvp_set.data.value_size)) |
K. Y. Srinivasan | b47a81d | 2012-08-13 10:06:52 -0700 | [diff] [blame] | 797 | hv_msg->error = HV_S_CONT; |
K. Y. Srinivasan | db42533 | 2012-03-16 08:02:26 -0700 | [diff] [blame] | 798 | break; |
| 799 | |
K. Y. Srinivasan | fa3d5b8 | 2012-03-16 08:02:25 -0700 | [diff] [blame] | 800 | case KVP_OP_GET: |
K. Y. Srinivasan | b47a81d | 2012-08-13 10:06:52 -0700 | [diff] [blame] | 801 | if (kvp_get_value(pool, |
K. Y. Srinivasan | db42533 | 2012-03-16 08:02:26 -0700 | [diff] [blame] | 802 | hv_msg->body.kvp_set.data.key, |
| 803 | hv_msg->body.kvp_set.data.key_size, |
| 804 | hv_msg->body.kvp_set.data.value, |
| 805 | hv_msg->body.kvp_set.data.value_size)) |
K. Y. Srinivasan | b47a81d | 2012-08-13 10:06:52 -0700 | [diff] [blame] | 806 | hv_msg->error = HV_S_CONT; |
K. Y. Srinivasan | db42533 | 2012-03-16 08:02:26 -0700 | [diff] [blame] | 807 | break; |
| 808 | |
K. Y. Srinivasan | fa3d5b8 | 2012-03-16 08:02:25 -0700 | [diff] [blame] | 809 | case KVP_OP_DELETE: |
K. Y. Srinivasan | b47a81d | 2012-08-13 10:06:52 -0700 | [diff] [blame] | 810 | if (kvp_key_delete(pool, |
K. Y. Srinivasan | db42533 | 2012-03-16 08:02:26 -0700 | [diff] [blame] | 811 | hv_msg->body.kvp_delete.key, |
| 812 | hv_msg->body.kvp_delete.key_size)) |
K. Y. Srinivasan | b47a81d | 2012-08-13 10:06:52 -0700 | [diff] [blame] | 813 | hv_msg->error = HV_S_CONT; |
K. Y. Srinivasan | db42533 | 2012-03-16 08:02:26 -0700 | [diff] [blame] | 814 | break; |
| 815 | |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 816 | default: |
K. Y. Srinivasan | 264033543 | 2012-02-02 16:56:50 -0800 | [diff] [blame] | 817 | break; |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 818 | } |
| 819 | |
K. Y. Srinivasan | b47a81d | 2012-08-13 10:06:52 -0700 | [diff] [blame] | 820 | if (op != KVP_OP_ENUMERATE) |
K. Y. Srinivasan | fa3d5b8 | 2012-03-16 08:02:25 -0700 | [diff] [blame] | 821 | goto kvp_done; |
| 822 | |
K. Y. Srinivasan | adc80ae | 2012-03-16 08:02:27 -0700 | [diff] [blame] | 823 | /* |
| 824 | * If the pool is KVP_POOL_AUTO, dynamically generate |
| 825 | * both the key and the value; if not read from the |
| 826 | * appropriate pool. |
| 827 | */ |
K. Y. Srinivasan | b47a81d | 2012-08-13 10:06:52 -0700 | [diff] [blame] | 828 | if (pool != KVP_POOL_AUTO) { |
| 829 | if (kvp_pool_enumerate(pool, |
K. Y. Srinivasan | adc80ae | 2012-03-16 08:02:27 -0700 | [diff] [blame] | 830 | hv_msg->body.kvp_enum_data.index, |
| 831 | hv_msg->body.kvp_enum_data.data.key, |
| 832 | HV_KVP_EXCHANGE_MAX_KEY_SIZE, |
| 833 | hv_msg->body.kvp_enum_data.data.value, |
K. Y. Srinivasan | b47a81d | 2012-08-13 10:06:52 -0700 | [diff] [blame] | 834 | HV_KVP_EXCHANGE_MAX_VALUE_SIZE)) |
| 835 | hv_msg->error = HV_S_CONT; |
K. Y. Srinivasan | adc80ae | 2012-03-16 08:02:27 -0700 | [diff] [blame] | 836 | goto kvp_done; |
| 837 | } |
| 838 | |
K. Y. Srinivasan | 264033543 | 2012-02-02 16:56:50 -0800 | [diff] [blame] | 839 | hv_msg = (struct hv_kvp_msg *)incoming_cn_msg->data; |
| 840 | key_name = (char *)hv_msg->body.kvp_enum_data.data.key; |
| 841 | key_value = (char *)hv_msg->body.kvp_enum_data.data.value; |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 842 | |
K. Y. Srinivasan | 264033543 | 2012-02-02 16:56:50 -0800 | [diff] [blame] | 843 | switch (hv_msg->body.kvp_enum_data.index) { |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 844 | case FullyQualifiedDomainName: |
| 845 | kvp_get_domain_name(key_value, |
| 846 | HV_KVP_EXCHANGE_MAX_VALUE_SIZE); |
| 847 | strcpy(key_name, "FullyQualifiedDomainName"); |
| 848 | break; |
| 849 | case IntegrationServicesVersion: |
| 850 | strcpy(key_name, "IntegrationServicesVersion"); |
| 851 | strcpy(key_value, lic_version); |
| 852 | break; |
| 853 | case NetworkAddressIPv4: |
K. Y. Srinivasan | 0ecaa19 | 2012-08-16 18:32:13 -0700 | [diff] [blame] | 854 | kvp_get_ip_address(AF_INET, NULL, KVP_OP_ENUMERATE, |
| 855 | key_value, HV_KVP_EXCHANGE_MAX_VALUE_SIZE); |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 856 | strcpy(key_name, "NetworkAddressIPv4"); |
| 857 | break; |
| 858 | case NetworkAddressIPv6: |
K. Y. Srinivasan | 0ecaa19 | 2012-08-16 18:32:13 -0700 | [diff] [blame] | 859 | kvp_get_ip_address(AF_INET6, NULL, KVP_OP_ENUMERATE, |
| 860 | key_value, HV_KVP_EXCHANGE_MAX_VALUE_SIZE); |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 861 | strcpy(key_name, "NetworkAddressIPv6"); |
| 862 | break; |
| 863 | case OSBuildNumber: |
| 864 | strcpy(key_value, os_build); |
| 865 | strcpy(key_name, "OSBuildNumber"); |
| 866 | break; |
| 867 | case OSName: |
| 868 | strcpy(key_value, os_name); |
| 869 | strcpy(key_name, "OSName"); |
| 870 | break; |
| 871 | case OSMajorVersion: |
| 872 | strcpy(key_value, os_major); |
| 873 | strcpy(key_name, "OSMajorVersion"); |
| 874 | break; |
| 875 | case OSMinorVersion: |
| 876 | strcpy(key_value, os_minor); |
| 877 | strcpy(key_name, "OSMinorVersion"); |
| 878 | break; |
| 879 | case OSVersion: |
| 880 | strcpy(key_value, os_build); |
| 881 | strcpy(key_name, "OSVersion"); |
| 882 | break; |
| 883 | case ProcessorArchitecture: |
| 884 | strcpy(key_value, processor_arch); |
| 885 | strcpy(key_name, "ProcessorArchitecture"); |
| 886 | break; |
| 887 | default: |
K. Y. Srinivasan | b47a81d | 2012-08-13 10:06:52 -0700 | [diff] [blame] | 888 | hv_msg->error = HV_S_CONT; |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 889 | break; |
| 890 | } |
| 891 | /* |
| 892 | * Send the value back to the kernel. The response is |
| 893 | * already in the receive buffer. Update the cn_msg header to |
| 894 | * reflect the key value that has been added to the message |
| 895 | */ |
K. Y. Srinivasan | fa3d5b8 | 2012-03-16 08:02:25 -0700 | [diff] [blame] | 896 | kvp_done: |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 897 | |
| 898 | incoming_cn_msg->id.idx = CN_KVP_IDX; |
| 899 | incoming_cn_msg->id.val = CN_KVP_VAL; |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 900 | incoming_cn_msg->ack = 0; |
K. Y. Srinivasan | 264033543 | 2012-02-02 16:56:50 -0800 | [diff] [blame] | 901 | incoming_cn_msg->len = sizeof(struct hv_kvp_msg); |
Ky Srinivasan | cc04acf | 2010-12-16 18:56:54 -0700 | [diff] [blame] | 902 | |
| 903 | len = netlink_send(fd, incoming_cn_msg); |
| 904 | if (len < 0) { |
| 905 | syslog(LOG_ERR, "net_link send failed; error:%d", len); |
| 906 | exit(-1); |
| 907 | } |
| 908 | } |
| 909 | |
| 910 | } |