This source file includes following definitions.
- pmix20_bfrop_unpack
- pmix20_bfrop_unpack_buffer
- pmix20_bfrop_unpack_bool
- pmix20_bfrop_unpack_int
- pmix20_bfrop_unpack_sizet
- pmix20_bfrop_unpack_pid
- pmix20_bfrop_unpack_byte
- pmix20_bfrop_unpack_int16
- pmix20_bfrop_unpack_int32
- pmix20_bfrop_unpack_datatype
- pmix20_bfrop_unpack_int64
- pmix20_bfrop_unpack_string
- pmix20_bfrop_unpack_float
- pmix20_bfrop_unpack_double
- pmix20_bfrop_unpack_timeval
- pmix20_bfrop_unpack_time
- pmix20_bfrop_unpack_status
- unpack_val
- pmix20_bfrop_unpack_value
- pmix20_bfrop_unpack_info
- pmix20_bfrop_unpack_pdata
- pmix20_bfrop_unpack_buf
- pmix20_bfrop_unpack_proc
- pmix20_bfrop_unpack_app
- pmix20_bfrop_unpack_kval
- pmix20_bfrop_unpack_modex
- pmix20_bfrop_unpack_persist
- pmix20_bfrop_unpack_scope
- pmix20_bfrop_unpack_range
- pmix20_bfrop_unpack_cmd
- pmix20_bfrop_unpack_infodirs
- pmix20_bfrop_unpack_bo
- pmix20_bfrop_unpack_ptr
- pmix20_bfrop_unpack_pstate
- pmix20_bfrop_unpack_pinfo
- pmix20_bfrop_unpack_darray
- pmix20_bfrop_unpack_rank
- pmix20_bfrop_unpack_query
- pmix20_bfrop_unpack_alloc_directive
- pmix20_bfrop_unpack_array
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26 #include <src/include/pmix_config.h>
27
28 #include "src/util/argv.h"
29 #include "src/util/error.h"
30 #include "src/util/output.h"
31 #include "src/mca/bfrops/base/base.h"
32 #include "bfrop_pmix20.h"
33 #include "internal.h"
34
35 pmix_status_t pmix20_bfrop_unpack(pmix_buffer_t *buffer,
36 void *dst, int32_t *num_vals,
37 pmix_data_type_t type)
38 {
39 pmix_status_t rc, ret;
40 int32_t local_num, n=1;
41 pmix_data_type_t local_type;
42 pmix_pointer_array_t *regtypes = &mca_bfrops_v20_component.types;
43
44
45 if (NULL == buffer || NULL == dst || NULL == num_vals) {
46 return PMIX_ERR_BAD_PARAM;
47 }
48
49
50
51
52 if (0 == *num_vals) {
53 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
54 "pmix20_bfrop_unpack: inadequate space ( %p, %p, %lu, %d )\n",
55 (void*)buffer, dst, (long unsigned int)*num_vals, (int)type);
56 return PMIX_ERR_UNPACK_INADEQUATE_SPACE;
57 }
58
59
60
61
62
63
64
65
66
67
68 if (PMIX_BFROP_BUFFER_FULLY_DESC == buffer->type) {
69 if (PMIX_SUCCESS != (rc = pmix20_bfrop_get_data_type(regtypes, buffer, &local_type))) {
70 *num_vals = 0;
71
72
73 return rc;
74 }
75 if (PMIX_INT32 != local_type) {
76 *num_vals = 0;
77 return PMIX_ERR_UNPACK_FAILURE;
78 }
79 }
80
81 n=1;
82 PMIX_BFROPS_UNPACK_TYPE(rc, buffer, &local_num, &n, PMIX_INT32, regtypes);
83 if (PMIX_SUCCESS != rc) {
84 *num_vals = 0;
85
86
87 return rc;
88 }
89
90 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
91 "pmix20_bfrop_unpack: found %d values for %d provided storage",
92 local_num, *num_vals);
93
94
95
96
97
98
99 if (local_num > *num_vals) {
100 local_num = *num_vals;
101 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
102 "pmix20_bfrop_unpack: inadequate space ( %p, %p, %lu, %d )\n",
103 (void*)buffer, dst, (long unsigned int)*num_vals, (int)type);
104 ret = PMIX_ERR_UNPACK_INADEQUATE_SPACE;
105 } else {
106 *num_vals = local_num;
107 ret = PMIX_SUCCESS;
108 }
109
110
111 if (PMIX_SUCCESS != (rc = pmix20_bfrop_unpack_buffer(regtypes, buffer, dst, &local_num, type))) {
112 *num_vals = 0;
113 ret = rc;
114 }
115
116 return ret;
117 }
118
119 pmix_status_t pmix20_bfrop_unpack_buffer(pmix_pointer_array_t *regtypes,
120 pmix_buffer_t *buffer, void *dst, int32_t *num_vals,
121 pmix_data_type_t type)
122 {
123 pmix_status_t rc;
124 pmix_data_type_t local_type, v20type;
125
126 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
127 "pmix20_bfrop_unpack_buffer( %p, %p, %lu, %d )\n",
128 (void*)buffer, dst, (long unsigned int)*num_vals, (int)type);
129
130
131 switch (type) {
132 case PMIX_COMMAND:
133 v20type = PMIX_UINT32;
134 break;
135 default:
136 v20type = type;
137 }
138
139
140 if (PMIX_BFROP_BUFFER_FULLY_DESC == buffer->type) {
141 if (PMIX_SUCCESS != (rc = pmix20_bfrop_get_data_type(regtypes, buffer, &local_type))) {
142 return rc;
143 }
144
145 if (v20type != local_type) {
146 pmix_output(0, "PMIX bfrop:unpack: got type %d when expecting type %d", local_type, v20type);
147 return PMIX_ERR_PACK_MISMATCH;
148 }
149 }
150 PMIX_BFROPS_UNPACK_TYPE(rc, buffer, dst, num_vals, v20type, regtypes);
151 return rc;
152 }
153
154
155
156
157
158
159
160 pmix_status_t pmix20_bfrop_unpack_bool(pmix_pointer_array_t *regtypes,
161 pmix_buffer_t *buffer, void *dest,
162 int32_t *num_vals, pmix_data_type_t type)
163 {
164 int32_t i;
165 uint8_t *src;
166 bool *dst;
167
168 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
169 "pmix20_bfrop_unpack_bool * %d\n", (int)*num_vals);
170
171 if (pmix_bfrop_too_small(buffer, *num_vals)) {
172 return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
173 }
174
175
176 src = (uint8_t*)buffer->unpack_ptr;
177 dst = (bool*)dest;
178
179 for (i=0; i < *num_vals; i++) {
180 if (src[i]) {
181 dst[i] = true;
182 } else {
183 dst[i] = false;
184 }
185 }
186
187
188 buffer->unpack_ptr += *num_vals;
189
190 return PMIX_SUCCESS;
191 }
192
193
194
195
196 pmix_status_t pmix20_bfrop_unpack_int(pmix_pointer_array_t *regtypes,
197 pmix_buffer_t *buffer, void *dest,
198 int32_t *num_vals, pmix_data_type_t type)
199 {
200 pmix_status_t ret;
201 pmix_data_type_t remote_type;
202
203 if (PMIX_SUCCESS != (ret = pmix20_bfrop_get_data_type(regtypes, buffer, &remote_type))) {
204 return ret;
205 }
206
207 if (remote_type == BFROP_TYPE_INT) {
208
209
210 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, dest,
211 num_vals, BFROP_TYPE_INT))) {
212 }
213 } else {
214
215 PMIX_BFROP_UNPACK_SIZE_MISMATCH(regtypes, int, remote_type, ret);
216 }
217
218 return ret;
219 }
220
221
222
223
224 pmix_status_t pmix20_bfrop_unpack_sizet(pmix_pointer_array_t *regtypes,
225 pmix_buffer_t *buffer, void *dest,
226 int32_t *num_vals, pmix_data_type_t type)
227 {
228 pmix_status_t ret;
229 pmix_data_type_t remote_type;
230
231 if (PMIX_SUCCESS != (ret = pmix20_bfrop_get_data_type(regtypes, buffer, &remote_type))) {
232 return ret;
233 }
234
235 if (remote_type == BFROP_TYPE_SIZE_T) {
236
237
238 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer,
239 dest, num_vals, BFROP_TYPE_SIZE_T))) {
240 }
241 } else {
242
243 PMIX_BFROP_UNPACK_SIZE_MISMATCH(regtypes, size_t, remote_type, ret);
244 }
245
246 return ret;
247 }
248
249
250
251
252 pmix_status_t pmix20_bfrop_unpack_pid(pmix_pointer_array_t *regtypes,
253 pmix_buffer_t *buffer, void *dest,
254 int32_t *num_vals, pmix_data_type_t type)
255 {
256 pmix_status_t ret;
257 pmix_data_type_t remote_type;
258
259 if (PMIX_SUCCESS != (ret = pmix20_bfrop_get_data_type(regtypes, buffer, &remote_type))) {
260 return ret;
261 }
262
263 if (remote_type == BFROP_TYPE_PID_T) {
264
265
266 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, dest, num_vals, BFROP_TYPE_PID_T))) {
267 }
268 } else {
269
270 PMIX_BFROP_UNPACK_SIZE_MISMATCH(regtypes, pid_t, remote_type, ret);
271 }
272
273 return ret;
274 }
275
276
277
278
279
280
281
282 pmix_status_t pmix20_bfrop_unpack_byte(pmix_pointer_array_t *regtypes,
283 pmix_buffer_t *buffer, void *dest,
284 int32_t *num_vals, pmix_data_type_t type)
285 {
286 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
287 "pmix20_bfrop_unpack_byte * %d\n", (int)*num_vals);
288
289 if (pmix_bfrop_too_small(buffer, *num_vals)) {
290 return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
291 }
292
293
294 memcpy(dest, buffer->unpack_ptr, *num_vals);
295
296
297 buffer->unpack_ptr += *num_vals;
298
299 return PMIX_SUCCESS;
300 }
301
302 pmix_status_t pmix20_bfrop_unpack_int16(pmix_pointer_array_t *regtypes,
303 pmix_buffer_t *buffer, void *dest,
304 int32_t *num_vals, pmix_data_type_t type)
305 {
306 int32_t i;
307 uint16_t tmp, *desttmp = (uint16_t*) dest;
308
309 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
310 "pmix20_bfrop_unpack_int16 * %d\n", (int)*num_vals);
311
312 if (pmix_bfrop_too_small(buffer, (*num_vals)*sizeof(tmp))) {
313 return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
314 }
315
316
317 for (i = 0; i < (*num_vals); ++i) {
318 memcpy( &(tmp), buffer->unpack_ptr, sizeof(tmp) );
319 tmp = pmix_ntohs(tmp);
320 memcpy(&desttmp[i], &tmp, sizeof(tmp));
321 buffer->unpack_ptr += sizeof(tmp);
322 }
323
324 return PMIX_SUCCESS;
325 }
326
327 pmix_status_t pmix20_bfrop_unpack_int32(pmix_pointer_array_t *regtypes,
328 pmix_buffer_t *buffer, void *dest,
329 int32_t *num_vals, pmix_data_type_t type)
330 {
331 int32_t i;
332 uint32_t tmp, *desttmp = (uint32_t*) dest;
333
334 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
335 "pmix20_bfrop_unpack_int32 * %d\n", (int)*num_vals);
336
337 if (pmix_bfrop_too_small(buffer, (*num_vals)*sizeof(tmp))) {
338 return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
339 }
340
341
342 for (i = 0; i < (*num_vals); ++i) {
343 memcpy( &(tmp), buffer->unpack_ptr, sizeof(tmp) );
344 tmp = ntohl(tmp);
345 memcpy(&desttmp[i], &tmp, sizeof(tmp));
346 buffer->unpack_ptr += sizeof(tmp);
347 }
348
349 return PMIX_SUCCESS;
350 }
351
352 pmix_status_t pmix20_bfrop_unpack_datatype(pmix_pointer_array_t *regtypes,
353 pmix_buffer_t *buffer, void *dest,
354 int32_t *num_vals, pmix_data_type_t type)
355 {
356 pmix_status_t ret;
357
358 PMIX_BFROPS_UNPACK_TYPE(ret, buffer, dest, num_vals, PMIX_INT16, regtypes);
359 return ret;
360 }
361
362 pmix_status_t pmix20_bfrop_unpack_int64(pmix_pointer_array_t *regtypes,
363 pmix_buffer_t *buffer, void *dest,
364 int32_t *num_vals, pmix_data_type_t type)
365 {
366 int32_t i;
367 uint64_t tmp, *desttmp = (uint64_t*) dest;
368
369 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
370 "pmix20_bfrop_unpack_int64 * %d\n", (int)*num_vals);
371
372 if (pmix_bfrop_too_small(buffer, (*num_vals)*sizeof(tmp))) {
373 return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
374 }
375
376
377 for (i = 0; i < (*num_vals); ++i) {
378 memcpy( &(tmp), buffer->unpack_ptr, sizeof(tmp) );
379 tmp = pmix_ntoh64(tmp);
380 memcpy(&desttmp[i], &tmp, sizeof(tmp));
381 buffer->unpack_ptr += sizeof(tmp);
382 }
383
384 return PMIX_SUCCESS;
385 }
386
387 pmix_status_t pmix20_bfrop_unpack_string(pmix_pointer_array_t *regtypes,
388 pmix_buffer_t *buffer, void *dest,
389 int32_t *num_vals, pmix_data_type_t type)
390 {
391 pmix_status_t ret;
392 int32_t i, len, n=1;
393 char **sdest = (char**) dest;
394
395 for (i = 0; i < (*num_vals); ++i) {
396 PMIX_BFROPS_UNPACK_TYPE(ret, buffer, &len, &n, PMIX_INT32, regtypes);
397 if (PMIX_SUCCESS != ret) {
398 return ret;
399 }
400 if (0 == len) {
401 sdest[i] = NULL;
402 } else {
403 sdest[i] = (char*)malloc(len);
404 if (NULL == sdest[i]) {
405 return PMIX_ERR_OUT_OF_RESOURCE;
406 }
407 PMIX_BFROPS_UNPACK_TYPE(ret, buffer, sdest[i], &len, PMIX_BYTE, regtypes);
408 if (PMIX_SUCCESS != ret) {
409 return ret;
410 }
411 }
412 }
413
414 return PMIX_SUCCESS;
415 }
416
417 pmix_status_t pmix20_bfrop_unpack_float(pmix_pointer_array_t *regtypes,
418 pmix_buffer_t *buffer, void *dest,
419 int32_t *num_vals, pmix_data_type_t type)
420 {
421 int32_t i, n;
422 float *desttmp = (float*) dest, tmp;
423 pmix_status_t ret;
424 char *convert;
425
426 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
427 "pmix20_bfrop_unpack_float * %d\n", (int)*num_vals);
428
429 if (pmix_bfrop_too_small(buffer, (*num_vals)*sizeof(float))) {
430 return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
431 }
432
433
434 for (i = 0; i < (*num_vals); ++i) {
435 n=1;
436 convert = NULL;
437 PMIX_BFROPS_UNPACK_TYPE(ret, buffer, &convert, &n, PMIX_STRING, regtypes);
438 if (PMIX_SUCCESS != ret) {
439 return ret;
440 }
441 if (NULL != convert) {
442 tmp = strtof(convert, NULL);
443 memcpy(&desttmp[i], &tmp, sizeof(tmp));
444 free(convert);
445 }
446 }
447 return PMIX_SUCCESS;
448 }
449
450 pmix_status_t pmix20_bfrop_unpack_double(pmix_pointer_array_t *regtypes,
451 pmix_buffer_t *buffer, void *dest,
452 int32_t *num_vals, pmix_data_type_t type)
453 {
454 int32_t i, n;
455 double *desttmp = (double*) dest, tmp;
456 pmix_status_t ret;
457 char *convert;
458
459 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
460 "pmix20_bfrop_unpack_double * %d\n", (int)*num_vals);
461
462 if (pmix_bfrop_too_small(buffer, (*num_vals)*sizeof(double))) {
463 return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
464 }
465
466
467 for (i = 0; i < (*num_vals); ++i) {
468 n=1;
469 convert = NULL;
470 PMIX_BFROPS_UNPACK_TYPE(ret, buffer, &convert, &n, PMIX_STRING, regtypes);
471 if (PMIX_SUCCESS != ret) {
472 return ret;
473 }
474 if (NULL != convert) {
475 tmp = strtod(convert, NULL);
476 memcpy(&desttmp[i], &tmp, sizeof(tmp));
477 free(convert);
478 }
479 }
480 return PMIX_SUCCESS;
481 }
482
483 pmix_status_t pmix20_bfrop_unpack_timeval(pmix_pointer_array_t *regtypes,
484 pmix_buffer_t *buffer, void *dest,
485 int32_t *num_vals, pmix_data_type_t type)
486 {
487 int32_t i, n;
488 int64_t tmp[2];
489 struct timeval *desttmp = (struct timeval *) dest, tt;
490 pmix_status_t ret;
491
492 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
493 "pmix20_bfrop_unpack_timeval * %d\n", (int)*num_vals);
494
495 if (pmix_bfrop_too_small(buffer, (*num_vals)*sizeof(struct timeval))) {
496 return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
497 }
498
499
500 for (i = 0; i < (*num_vals); ++i) {
501 n=2;
502 PMIX_BFROPS_UNPACK_TYPE(ret, buffer, tmp, &n, PMIX_INT64, regtypes);
503 if (PMIX_SUCCESS != ret) {
504 return ret;
505 }
506 tt.tv_sec = tmp[0];
507 tt.tv_usec = tmp[1];
508 memcpy(&desttmp[i], &tt, sizeof(tt));
509 }
510 return PMIX_SUCCESS;
511 }
512
513 pmix_status_t pmix20_bfrop_unpack_time(pmix_pointer_array_t *regtypes,
514 pmix_buffer_t *buffer, void *dest,
515 int32_t *num_vals, pmix_data_type_t type)
516 {
517 int32_t i, n;
518 time_t *desttmp = (time_t *) dest, tmp;
519 pmix_status_t ret;
520 uint64_t ui64;
521
522
523
524
525
526 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
527 "pmix20_bfrop_unpack_time * %d\n", (int)*num_vals);
528
529 for (i = 0; i < (*num_vals); ++i) {
530 n=1;
531 PMIX_BFROPS_UNPACK_TYPE(ret, buffer, &ui64, &n, PMIX_UINT64, regtypes);
532 if (PMIX_SUCCESS != ret) {
533 return ret;
534 }
535 tmp = (time_t)ui64;
536 memcpy(&desttmp[i], &tmp, sizeof(tmp));
537 }
538 return PMIX_SUCCESS;
539 }
540
541
542 pmix_status_t pmix20_bfrop_unpack_status(pmix_pointer_array_t *regtypes,
543 pmix_buffer_t *buffer, void *dest,
544 int32_t *num_vals, pmix_data_type_t type)
545 {
546 pmix_status_t ret;
547
548 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
549 "pmix20_bfrop_unpack_status * %d\n", (int)*num_vals);
550
551 if (pmix_bfrop_too_small(buffer, (*num_vals)*(sizeof(pmix_status_t)))) {
552 return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
553 }
554
555
556 PMIX_BFROPS_UNPACK_TYPE(ret, buffer, dest, num_vals, PMIX_INT32, regtypes);
557 return ret;
558 }
559
560
561
562
563
564
565
566 static pmix_status_t unpack_val(pmix_pointer_array_t *regtypes,
567 pmix_buffer_t *buffer, pmix_value_t *val)
568 {
569 int32_t m;
570 pmix_status_t ret;
571
572 m = 1;
573 switch (val->type) {
574 case PMIX_UNDEF:
575 break;
576 case PMIX_BOOL:
577 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, &val->data.flag, &m, PMIX_BOOL))) {
578 return ret;
579 }
580 break;
581 case PMIX_BYTE:
582 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, &val->data.byte, &m, PMIX_BYTE))) {
583 return ret;
584 }
585 break;
586 case PMIX_STRING:
587 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, &val->data.string, &m, PMIX_STRING))) {
588 return ret;
589 }
590 break;
591 case PMIX_SIZE:
592 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, &val->data.size, &m, PMIX_SIZE))) {
593 return ret;
594 }
595 break;
596 case PMIX_PID:
597 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, &val->data.pid, &m, PMIX_PID))) {
598 return ret;
599 }
600 break;
601 case PMIX_INT:
602 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, &val->data.integer, &m, PMIX_INT))) {
603 return ret;
604 }
605 break;
606 case PMIX_INT8:
607 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, &val->data.int8, &m, PMIX_INT8))) {
608 return ret;
609 }
610 break;
611 case PMIX_INT16:
612 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, &val->data.int16, &m, PMIX_INT16))) {
613 return ret;
614 }
615 break;
616 case PMIX_INT32:
617 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, &val->data.int32, &m, PMIX_INT32))) {
618 return ret;
619 }
620 break;
621 case PMIX_INT64:
622 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, &val->data.int64, &m, PMIX_INT64))) {
623 return ret;
624 }
625 break;
626 case PMIX_UINT:
627 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, &val->data.uint, &m, PMIX_UINT))) {
628 return ret;
629 }
630 break;
631 case PMIX_UINT8:
632 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, &val->data.uint8, &m, PMIX_UINT8))) {
633 return ret;
634 }
635 break;
636 case PMIX_UINT16:
637 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, &val->data.uint16, &m, PMIX_UINT16))) {
638 return ret;
639 }
640 break;
641 case PMIX_UINT32:
642 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, &val->data.uint32, &m, PMIX_UINT32))) {
643 return ret;
644 }
645 break;
646 case PMIX_UINT64:
647 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, &val->data.uint64, &m, PMIX_UINT64))) {
648 return ret;
649 }
650 break;
651 case PMIX_FLOAT:
652 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, &val->data.fval, &m, PMIX_FLOAT))) {
653 return ret;
654 }
655 break;
656 case PMIX_DOUBLE:
657 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, &val->data.dval, &m, PMIX_DOUBLE))) {
658 return ret;
659 }
660 break;
661 case PMIX_TIMEVAL:
662 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, &val->data.tv, &m, PMIX_TIMEVAL))) {
663 return ret;
664 }
665 break;
666 case PMIX_TIME:
667 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, &val->data.time, &m, PMIX_TIME))) {
668 return ret;
669 }
670 break;
671 case PMIX_STATUS:
672 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, &val->data.status, &m, PMIX_STATUS))) {
673 return ret;
674 }
675 break;
676 case PMIX_PROC:
677
678 PMIX_PROC_CREATE(val->data.proc, m);
679 if (NULL == val->data.proc) {
680 return PMIX_ERR_NOMEM;
681 }
682 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, val->data.proc, &m, PMIX_PROC))) {
683 return ret;
684 }
685 break;
686 case PMIX_PROC_RANK:
687 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, &val->data.rank, &m, PMIX_PROC_RANK))) {
688 return ret;
689 }
690 break;
691 case PMIX_BYTE_OBJECT:
692 case PMIX_COMPRESSED_STRING:
693 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, &val->data.bo, &m, PMIX_BYTE_OBJECT))) {
694 return ret;
695 }
696 break;
697 case PMIX_PERSIST:
698 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, &val->data.proc, &m, PMIX_PROC))) {
699 return ret;
700 }
701 break;
702 case PMIX_POINTER:
703 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, &val->data.ptr, &m, PMIX_POINTER))) {
704 return ret;
705 }
706 break;
707 case PMIX_SCOPE:
708 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, &val->data.scope, &m, PMIX_SCOPE))) {
709 return ret;
710 }
711 break;
712 case PMIX_DATA_RANGE:
713 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, &val->data.range, &m, PMIX_DATA_RANGE))) {
714 return ret;
715 }
716 break;
717 case PMIX_PROC_STATE:
718 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, &val->data.state, &m, PMIX_PROC_STATE))) {
719 return ret;
720 }
721 break;
722 case PMIX_PROC_INFO:
723
724 PMIX_PROC_INFO_CREATE(val->data.pinfo, 1);
725 if (NULL == val->data.pinfo) {
726 return PMIX_ERR_NOMEM;
727 }
728 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, val->data.pinfo, &m, PMIX_PROC_INFO))) {
729 return ret;
730 }
731 break;
732 case PMIX_DATA_ARRAY:
733
734 val->data.darray = (pmix_data_array_t*)malloc(sizeof(pmix_data_array_t));
735 if (NULL == val->data.darray) {
736 return PMIX_ERR_NOMEM;
737 }
738 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, val->data.darray, &m, PMIX_DATA_ARRAY))) {
739 return ret;
740 }
741 break;
742 case PMIX_QUERY:
743 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, val->data.darray, &m, PMIX_QUERY))) {
744 return ret;
745 }
746 break;
747
748 case PMIX_INFO_ARRAY:
749
750
751 val->data.darray = (pmix_data_array_t*)calloc(1, sizeof(pmix_data_array_t));
752 val->data.darray->type = PMIX_INFO_ARRAY;
753 val->data.darray->size = m;
754
755 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, &val->data.darray->array, &m, PMIX_INFO_ARRAY))) {
756 return ret;
757 }
758 break;
759
760 default:
761 pmix_output(0, "UNPACK-PMIX-VALUE: UNSUPPORTED TYPE %d", (int)val->type);
762 return PMIX_ERROR;
763 }
764
765 return PMIX_SUCCESS;
766 }
767
768 pmix_status_t pmix20_bfrop_unpack_value(pmix_pointer_array_t *regtypes,
769 pmix_buffer_t *buffer, void *dest,
770 int32_t *num_vals, pmix_data_type_t type)
771 {
772 pmix_value_t *ptr;
773 int32_t i, n;
774 pmix_status_t ret;
775
776 ptr = (pmix_value_t *) dest;
777 n = *num_vals;
778
779 for (i = 0; i < n; ++i) {
780
781 if (PMIX_SUCCESS != (ret = pmix20_bfrop_get_data_type(regtypes, buffer, &ptr[i].type))) {
782 return ret;
783 }
784
785 if (PMIX_SUCCESS != (ret = unpack_val(regtypes, buffer, &ptr[i])) ) {
786 return ret;
787 }
788 }
789 return PMIX_SUCCESS;
790 }
791
792 pmix_status_t pmix20_bfrop_unpack_info(pmix_pointer_array_t *regtypes,
793 pmix_buffer_t *buffer, void *dest,
794 int32_t *num_vals, pmix_data_type_t type)
795 {
796 pmix_info_t *ptr;
797 int32_t i, n, m;
798 pmix_status_t ret;
799 char *tmp;
800
801 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
802 "pmix20_bfrop_unpack: %d info", *num_vals);
803
804 ptr = (pmix_info_t *) dest;
805 n = *num_vals;
806
807 for (i = 0; i < n; ++i) {
808 memset(ptr[i].key, 0, sizeof(ptr[i].key));
809 memset(&ptr[i].value, 0, sizeof(pmix_value_t));
810
811 m=1;
812 tmp = NULL;
813 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_string(regtypes, buffer, &tmp, &m, PMIX_STRING))) {
814 PMIX_ERROR_LOG(ret);
815 return ret;
816 }
817 if (NULL == tmp) {
818 PMIX_ERROR_LOG(PMIX_ERROR);
819 return PMIX_ERROR;
820 }
821 pmix_strncpy(ptr[i].key, tmp, PMIX_MAX_KEYLEN);
822 free(tmp);
823
824 m=1;
825 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_infodirs(regtypes, buffer, &ptr[i].flags, &m, PMIX_INFO_DIRECTIVES))) {
826 PMIX_ERROR_LOG(ret);
827 return ret;
828 }
829
830
831
832 m=1;
833 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_int(regtypes, buffer, &ptr[i].value.type, &m, PMIX_INT))) {
834 PMIX_ERROR_LOG(ret);
835 return ret;
836 }
837 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
838 "pmix20_bfrop_unpack: info type %d", ptr[i].value.type);
839 m=1;
840 if (PMIX_SUCCESS != (ret = unpack_val(regtypes, buffer, &ptr[i].value))) {
841 PMIX_ERROR_LOG(ret);
842 return ret;
843 }
844 }
845 return PMIX_SUCCESS;
846 }
847
848 pmix_status_t pmix20_bfrop_unpack_pdata(pmix_pointer_array_t *regtypes,
849 pmix_buffer_t *buffer, void *dest,
850 int32_t *num_vals, pmix_data_type_t type)
851 {
852 pmix_pdata_t *ptr;
853 int32_t i, n, m;
854 pmix_status_t ret;
855 char *tmp;
856
857 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
858 "pmix20_bfrop_unpack: %d pdata", *num_vals);
859
860 ptr = (pmix_pdata_t *) dest;
861 n = *num_vals;
862
863 for (i = 0; i < n; ++i) {
864 PMIX_PDATA_CONSTRUCT(&ptr[i]);
865
866 m=1;
867 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_proc(regtypes, buffer, &ptr[i].proc, &m, PMIX_PROC))) {
868 return ret;
869 }
870
871 m=1;
872 tmp = NULL;
873 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_string(regtypes, buffer, &tmp, &m, PMIX_STRING))) {
874 return ret;
875 }
876 if (NULL == tmp) {
877 return PMIX_ERROR;
878 }
879 pmix_strncpy(ptr[i].key, tmp, PMIX_MAX_KEYLEN);
880 free(tmp);
881
882
883
884 m=1;
885 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_int(regtypes, buffer, &ptr[i].value.type, &m, PMIX_INT))) {
886 return ret;
887 }
888 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
889 "pmix20_bfrop_unpack: pdata type %d", ptr[i].value.type);
890 m=1;
891 if (PMIX_SUCCESS != (ret = unpack_val(regtypes, buffer, &ptr[i].value))) {
892 return ret;
893 }
894 }
895 return PMIX_SUCCESS;
896 }
897
898 pmix_status_t pmix20_bfrop_unpack_buf(pmix_pointer_array_t *regtypes,
899 pmix_buffer_t *buffer, void *dest,
900 int32_t *num_vals, pmix_data_type_t type)
901 {
902 pmix_buffer_t *ptr;
903 int32_t i, n, m;
904 pmix_status_t ret;
905 size_t nbytes;
906
907 ptr = (pmix_buffer_t *) dest;
908 n = *num_vals;
909
910 for (i = 0; i < n; ++i) {
911
912 m=1;
913 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_sizet(regtypes, buffer, &nbytes, &m, PMIX_SIZE))) {
914 return ret;
915 }
916 m = nbytes;
917
918 if (0 < nbytes) {
919 ptr[i].base_ptr = (char*)malloc(nbytes);
920
921 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_byte(regtypes, buffer, ptr[i].base_ptr, &m, PMIX_BYTE))) {
922 return ret;
923 }
924 }
925 ptr[i].pack_ptr = ptr[i].base_ptr + m;
926 ptr[i].unpack_ptr = ptr[i].base_ptr;
927 ptr[i].bytes_allocated = nbytes;
928 ptr[i].bytes_used = m;
929 }
930 return PMIX_SUCCESS;
931 }
932
933 pmix_status_t pmix20_bfrop_unpack_proc(pmix_pointer_array_t *regtypes,
934 pmix_buffer_t *buffer, void *dest,
935 int32_t *num_vals, pmix_data_type_t type)
936 {
937 pmix_proc_t *ptr;
938 int32_t i, n, m;
939 pmix_status_t ret;
940 char *tmp;
941
942 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
943 "pmix20_bfrop_unpack: %d procs", *num_vals);
944
945 ptr = (pmix_proc_t *) dest;
946 n = *num_vals;
947
948 for (i = 0; i < n; ++i) {
949 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
950 "pmix20_bfrop_unpack: init proc[%d]", i);
951 memset(&ptr[i], 0, sizeof(pmix_proc_t));
952
953 m=1;
954 tmp = NULL;
955 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_string(regtypes, buffer, &tmp, &m, PMIX_STRING))) {
956 return ret;
957 }
958 if (NULL == tmp) {
959 return PMIX_ERROR;
960 }
961 pmix_strncpy(ptr[i].nspace, tmp, PMIX_MAX_NSLEN);
962 free(tmp);
963
964 m=1;
965 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_rank(regtypes, buffer, &ptr[i].rank, &m, PMIX_PROC_RANK))) {
966 return ret;
967 }
968 }
969 return PMIX_SUCCESS;
970 }
971
972 pmix_status_t pmix20_bfrop_unpack_app(pmix_pointer_array_t *regtypes,
973 pmix_buffer_t *buffer, void *dest,
974 int32_t *num_vals, pmix_data_type_t type)
975 {
976 pmix_app_t *ptr;
977 int32_t i, k, n, m;
978 pmix_status_t ret;
979 int32_t nval;
980 char *tmp;
981
982 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
983 "pmix20_bfrop_unpack: %d apps", *num_vals);
984
985 ptr = (pmix_app_t *) dest;
986 n = *num_vals;
987
988 for (i = 0; i < n; ++i) {
989
990 PMIX_APP_CONSTRUCT(&ptr[i]);
991
992 m=1;
993 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_string(regtypes, buffer, &ptr[i].cmd, &m, PMIX_STRING))) {
994 return ret;
995 }
996
997 m=1;
998 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_int(regtypes, buffer, &nval, &m, PMIX_INT32))) {
999 return ret;
1000 }
1001
1002 for (k=0; k < nval; k++) {
1003 m=1;
1004 tmp = NULL;
1005 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_string(regtypes, buffer, &tmp, &m, PMIX_STRING))) {
1006 return ret;
1007 }
1008 if (NULL == tmp) {
1009 return PMIX_ERROR;
1010 }
1011 pmix_argv_append_nosize(&ptr[i].argv, tmp);
1012 free(tmp);
1013 }
1014
1015 m=1;
1016 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_int32(regtypes, buffer, &nval, &m, PMIX_INT32))) {
1017 return ret;
1018 }
1019 for (k=0; k < nval; k++) {
1020 m=1;
1021 tmp = NULL;
1022 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_string(regtypes, buffer, &tmp, &m, PMIX_STRING))) {
1023 return ret;
1024 }
1025 if (NULL == tmp) {
1026 return PMIX_ERROR;
1027 }
1028 pmix_argv_append_nosize(&ptr[i].env, tmp);
1029 free(tmp);
1030 }
1031
1032 m=1;
1033 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_string(regtypes, buffer, &ptr[i].cwd, &m, PMIX_STRING))) {
1034 return ret;
1035 }
1036
1037 m=1;
1038 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_int(regtypes, buffer, &ptr[i].maxprocs, &m, PMIX_INT))) {
1039 return ret;
1040 }
1041
1042 m=1;
1043 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_sizet(regtypes, buffer, &ptr[i].ninfo, &m, PMIX_SIZE))) {
1044 return ret;
1045 }
1046 if (0 < ptr[i].ninfo) {
1047 PMIX_INFO_CREATE(ptr[i].info, ptr[i].ninfo);
1048 m = ptr[i].ninfo;
1049 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_info(regtypes, buffer, ptr[i].info, &m, PMIX_INFO))) {
1050 return ret;
1051 }
1052 }
1053 }
1054 return PMIX_SUCCESS;
1055 }
1056
1057 pmix_status_t pmix20_bfrop_unpack_kval(pmix_pointer_array_t *regtypes,
1058 pmix_buffer_t *buffer, void *dest,
1059 int32_t *num_vals, pmix_data_type_t type)
1060 {
1061 pmix_kval_t *ptr;
1062 int32_t i, n, m;
1063 pmix_status_t ret;
1064
1065 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
1066 "pmix20_bfrop_unpack: %d kvals", *num_vals);
1067
1068 ptr = (pmix_kval_t*) dest;
1069 n = *num_vals;
1070
1071 for (i = 0; i < n; ++i) {
1072 PMIX_CONSTRUCT(&ptr[i], pmix_kval_t);
1073
1074 m = 1;
1075 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_string(regtypes, buffer, &ptr[i].key, &m, PMIX_STRING))) {
1076 PMIX_ERROR_LOG(ret);
1077 return ret;
1078 }
1079
1080 ptr[i].value = (pmix_value_t*)malloc(sizeof(pmix_value_t));
1081
1082 m = 1;
1083 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_value(regtypes, buffer, ptr[i].value, &m, PMIX_VALUE))) {
1084 PMIX_ERROR_LOG(ret);
1085 return ret;
1086 }
1087 }
1088 return PMIX_SUCCESS;
1089 }
1090
1091 pmix_status_t pmix20_bfrop_unpack_modex(pmix_pointer_array_t *regtypes,
1092 pmix_buffer_t *buffer, void *dest,
1093 int32_t *num_vals, pmix_data_type_t type)
1094 {
1095 pmix_modex_data_t *ptr;
1096 int32_t i, n, m;
1097 pmix_status_t ret;
1098
1099 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
1100 "pmix20_bfrop_unpack: %d modex", *num_vals);
1101
1102 ptr = (pmix_modex_data_t *) dest;
1103 n = *num_vals;
1104
1105 for (i = 0; i < n; ++i) {
1106 memset(&ptr[i], 0, sizeof(pmix_modex_data_t));
1107
1108 m=1;
1109 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_sizet(regtypes, buffer, &ptr[i].size, &m, PMIX_SIZE))) {
1110 return ret;
1111 }
1112 if (0 < ptr[i].size) {
1113 ptr[i].blob = (uint8_t*)malloc(ptr[i].size * sizeof(uint8_t));
1114 m=ptr[i].size;
1115 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_byte(regtypes, buffer, ptr[i].blob, &m, PMIX_UINT8))) {
1116 return ret;
1117 }
1118 }
1119 }
1120 return PMIX_SUCCESS;
1121 }
1122
1123 pmix_status_t pmix20_bfrop_unpack_persist(pmix_pointer_array_t *regtypes,
1124 pmix_buffer_t *buffer, void *dest,
1125 int32_t *num_vals, pmix_data_type_t type)
1126 {
1127 return pmix20_bfrop_unpack_byte(regtypes, buffer, dest, num_vals, PMIX_UINT8);
1128 }
1129
1130 pmix_status_t pmix20_bfrop_unpack_scope(pmix_pointer_array_t *regtypes,
1131 pmix_buffer_t *buffer, void *dest,
1132 int32_t *num_vals, pmix_data_type_t type)
1133 {
1134 return pmix20_bfrop_unpack_byte(regtypes, buffer, dest, num_vals, PMIX_UINT8);
1135 }
1136
1137 pmix_status_t pmix20_bfrop_unpack_range(pmix_pointer_array_t *regtypes,
1138 pmix_buffer_t *buffer, void *dest,
1139 int32_t *num_vals, pmix_data_type_t type)
1140 {
1141 return pmix20_bfrop_unpack_byte(regtypes, buffer, dest, num_vals, PMIX_UINT8);
1142 }
1143
1144 pmix_status_t pmix20_bfrop_unpack_cmd(pmix_pointer_array_t *regtypes,
1145 pmix_buffer_t *buffer, void *dest,
1146 int32_t *num_vals, pmix_data_type_t type)
1147 {
1148 return pmix20_bfrop_unpack_byte(regtypes, buffer, dest, num_vals, PMIX_UINT8);
1149 }
1150
1151 pmix_status_t pmix20_bfrop_unpack_infodirs(pmix_pointer_array_t *regtypes,
1152 pmix_buffer_t *buffer, void *dest,
1153 int32_t *num_vals, pmix_data_type_t type)
1154 {
1155 return pmix20_bfrop_unpack_int32(regtypes, buffer, dest, num_vals, PMIX_UINT32);
1156 }
1157
1158 pmix_status_t pmix20_bfrop_unpack_bo(pmix_pointer_array_t *regtypes,
1159 pmix_buffer_t *buffer, void *dest,
1160 int32_t *num_vals, pmix_data_type_t type)
1161 {
1162 pmix_byte_object_t *ptr;
1163 int32_t i, n, m;
1164 pmix_status_t ret;
1165
1166 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
1167 "pmix20_bfrop_unpack: %d byte_object", *num_vals);
1168
1169 ptr = (pmix_byte_object_t *) dest;
1170 n = *num_vals;
1171
1172 for (i = 0; i < n; ++i) {
1173 memset(&ptr[i], 0, sizeof(pmix_byte_object_t));
1174
1175 m=1;
1176 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_sizet(regtypes, buffer, &ptr[i].size, &m, PMIX_SIZE))) {
1177 return ret;
1178 }
1179 if (0 < ptr[i].size) {
1180 ptr[i].bytes = (char*)malloc(ptr[i].size * sizeof(char));
1181 m=ptr[i].size;
1182 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_byte(regtypes, buffer, ptr[i].bytes, &m, PMIX_BYTE))) {
1183 return ret;
1184 }
1185 }
1186 }
1187 return PMIX_SUCCESS;
1188 }
1189
1190 pmix_status_t pmix20_bfrop_unpack_ptr(pmix_pointer_array_t *regtypes,
1191 pmix_buffer_t *buffer, void *dest,
1192 int32_t *num_vals, pmix_data_type_t type)
1193 {
1194 uint8_t foo=1;
1195 int32_t cnt=1;
1196
1197
1198
1199 return pmix20_bfrop_unpack_byte(regtypes, buffer, &foo, &cnt, PMIX_UINT8);
1200 }
1201
1202 pmix_status_t pmix20_bfrop_unpack_pstate(pmix_pointer_array_t *regtypes,
1203 pmix_buffer_t *buffer, void *dest,
1204 int32_t *num_vals, pmix_data_type_t type)
1205 {
1206 return pmix20_bfrop_unpack_byte(regtypes, buffer, dest, num_vals, PMIX_UINT8);
1207 }
1208
1209
1210 pmix_status_t pmix20_bfrop_unpack_pinfo(pmix_pointer_array_t *regtypes,
1211 pmix_buffer_t *buffer, void *dest,
1212 int32_t *num_vals, pmix_data_type_t type)
1213 {
1214 pmix_proc_info_t *ptr;
1215 int32_t i, n, m;
1216 pmix_status_t ret;
1217
1218 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
1219 "pmix20_bfrop_unpack: %d pinfo", *num_vals);
1220
1221 ptr = (pmix_proc_info_t *) dest;
1222 n = *num_vals;
1223
1224 for (i = 0; i < n; ++i) {
1225 PMIX_PROC_INFO_CONSTRUCT(&ptr[i]);
1226
1227 m=1;
1228 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_proc(regtypes, buffer, &ptr[i].proc, &m, PMIX_PROC))) {
1229 return ret;
1230 }
1231
1232 m=1;
1233 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_string(regtypes, buffer, &ptr[i].hostname, &m, PMIX_STRING))) {
1234 return ret;
1235 }
1236
1237 m=1;
1238 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_string(regtypes, buffer, &ptr[i].executable_name, &m, PMIX_STRING))) {
1239 return ret;
1240 }
1241
1242 m=1;
1243 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_pid(regtypes, buffer, &ptr[i].pid, &m, PMIX_PID))) {
1244 return ret;
1245 }
1246
1247 m=1;
1248 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_pstate(regtypes, buffer, &ptr[i].state, &m, PMIX_PROC_STATE))) {
1249 return ret;
1250 }
1251 }
1252 return PMIX_SUCCESS;
1253 }
1254
1255 pmix_status_t pmix20_bfrop_unpack_darray(pmix_pointer_array_t *regtypes,
1256 pmix_buffer_t *buffer, void *dest,
1257 int32_t *num_vals, pmix_data_type_t type)
1258 {
1259 pmix_data_array_t *ptr;
1260 int32_t i, n, m;
1261 pmix_status_t ret;
1262 size_t nbytes;
1263
1264 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
1265 "pmix20_bfrop_unpack: %d data arrays", *num_vals);
1266
1267 ptr = (pmix_data_array_t *) dest;
1268 n = *num_vals;
1269
1270 for (i = 0; i < n; ++i) {
1271 memset(&ptr[i], 0, sizeof(pmix_data_array_t));
1272
1273 m=1;
1274 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_datatype(regtypes, buffer, &ptr[i].type, &m, PMIX_DATA_TYPE))) {
1275 return ret;
1276 }
1277
1278 m=1;
1279 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_sizet(regtypes, buffer, &ptr[i].size, &m, PMIX_SIZE))) {
1280 return ret;
1281 }
1282 if (0 == ptr[i].size || PMIX_UNDEF == ptr[i].type) {
1283
1284 continue;
1285 }
1286
1287 m = ptr[i].size;
1288 switch(ptr[i].type) {
1289 case PMIX_BOOL:
1290 nbytes = sizeof(bool);
1291 break;
1292 case PMIX_BYTE:
1293 case PMIX_INT8:
1294 case PMIX_UINT8:
1295 nbytes = sizeof(int8_t);
1296 break;
1297 case PMIX_INT16:
1298 case PMIX_UINT16:
1299 nbytes = sizeof(int16_t);
1300 break;
1301 case PMIX_INT32:
1302 case PMIX_UINT32:
1303 nbytes = sizeof(int32_t);
1304 break;
1305 case PMIX_INT64:
1306 case PMIX_UINT64:
1307 nbytes = sizeof(int64_t);
1308 break;
1309 case PMIX_STRING:
1310 nbytes = sizeof(char*);
1311 break;
1312 case PMIX_SIZE:
1313 nbytes = sizeof(size_t);
1314 break;
1315 case PMIX_PID:
1316 nbytes = sizeof(pid_t);
1317 break;
1318 case PMIX_INT:
1319 case PMIX_UINT:
1320 nbytes = sizeof(int);
1321 break;
1322 case PMIX_FLOAT:
1323 nbytes = sizeof(float);
1324 break;
1325 case PMIX_DOUBLE:
1326 nbytes = sizeof(double);
1327 break;
1328 case PMIX_TIMEVAL:
1329 nbytes = sizeof(struct timeval);
1330 break;
1331 case PMIX_TIME:
1332 nbytes = sizeof(time_t);
1333 break;
1334 case PMIX_STATUS:
1335 nbytes = sizeof(pmix_status_t);
1336 break;
1337 case PMIX_INFO:
1338 nbytes = sizeof(pmix_info_t);
1339 break;
1340 case PMIX_PROC:
1341 nbytes = sizeof(pmix_proc_t);
1342 break;
1343 case PMIX_BYTE_OBJECT:
1344 case PMIX_COMPRESSED_STRING:
1345 nbytes = sizeof(pmix_byte_object_t);
1346 break;
1347 case PMIX_PERSIST:
1348 nbytes = sizeof(pmix_persistence_t);
1349 break;
1350 case PMIX_SCOPE:
1351 nbytes = sizeof(pmix_scope_t);
1352 break;
1353 case PMIX_DATA_RANGE:
1354 nbytes = sizeof(pmix_data_range_t);
1355 break;
1356 case PMIX_PROC_STATE:
1357 nbytes = sizeof(pmix_proc_state_t);
1358 break;
1359 case PMIX_PROC_INFO:
1360 nbytes = sizeof(pmix_proc_info_t);
1361 break;
1362 case PMIX_QUERY:
1363 nbytes = sizeof(pmix_query_t);
1364 default:
1365 return PMIX_ERR_NOT_SUPPORTED;
1366 }
1367 if (NULL == (ptr[i].array = malloc(m * nbytes))) {
1368 return PMIX_ERR_NOMEM;
1369 }
1370 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_buffer(regtypes, buffer, ptr[i].array, &m, ptr[i].type))) {
1371 return ret;
1372 }
1373 }
1374 return PMIX_SUCCESS;
1375 }
1376
1377 pmix_status_t pmix20_bfrop_unpack_rank(pmix_pointer_array_t *regtypes,
1378 pmix_buffer_t *buffer, void *dest,
1379 int32_t *num_vals, pmix_data_type_t type)
1380 {
1381 return pmix20_bfrop_unpack_int32(regtypes, buffer, dest, num_vals, PMIX_UINT32);
1382 }
1383
1384 pmix_status_t pmix20_bfrop_unpack_query(pmix_pointer_array_t *regtypes,
1385 pmix_buffer_t *buffer, void *dest,
1386 int32_t *num_vals, pmix_data_type_t type)
1387 {
1388 pmix_query_t *ptr;
1389 int32_t i, n, m;
1390 pmix_status_t ret;
1391 int32_t nkeys;
1392
1393 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
1394 "pmix20_bfrop_unpack: %d queries", *num_vals);
1395
1396 ptr = (pmix_query_t *) dest;
1397 n = *num_vals;
1398
1399 for (i = 0; i < n; ++i) {
1400 PMIX_QUERY_CONSTRUCT(&ptr[i]);
1401
1402 m=1;
1403 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_int32(regtypes, buffer, &nkeys, &m, PMIX_INT32))) {
1404 return ret;
1405 }
1406 if (0 < nkeys) {
1407
1408 if (NULL == (ptr[i].keys = (char**)calloc(nkeys+1, sizeof(char*)))) {
1409 return PMIX_ERR_NOMEM;
1410 }
1411
1412 m=nkeys;
1413 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_string(regtypes, buffer, ptr[i].keys, &m, PMIX_STRING))) {
1414 return ret;
1415 }
1416 }
1417
1418 m=1;
1419 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_sizet(regtypes, buffer, &ptr[i].nqual, &m, PMIX_SIZE))) {
1420 return ret;
1421 }
1422 if (0 < ptr[i].nqual) {
1423
1424 PMIX_INFO_CREATE(ptr[i].qualifiers, ptr[i].nqual);
1425 m = ptr[i].nqual;
1426 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_info(regtypes, buffer, ptr[i].qualifiers, &m, PMIX_INFO))) {
1427 return ret;
1428 }
1429 }
1430 }
1431 return PMIX_SUCCESS;
1432 }
1433
1434 pmix_status_t pmix20_bfrop_unpack_alloc_directive(pmix_pointer_array_t *regtypes,
1435 pmix_buffer_t *buffer, void *dest,
1436 int32_t *num_vals, pmix_data_type_t type)
1437 {
1438 return pmix20_bfrop_unpack_byte(regtypes, buffer, dest, num_vals, PMIX_UINT8);
1439 }
1440
1441
1442
1443 pmix_status_t pmix20_bfrop_unpack_array(pmix_pointer_array_t *regtypes,
1444 pmix_buffer_t *buffer, void *dest,
1445 int32_t *num_vals, pmix_data_type_t type)
1446 {
1447 pmix_info_array_t *ptr;
1448 int32_t i, n, m;
1449 pmix_status_t ret;
1450
1451 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
1452 "pmix20_bfrop_unpack: %d info arrays", *num_vals);
1453
1454 ptr = (pmix_info_array_t*) dest;
1455 n = *num_vals;
1456
1457 for (i = 0; i < n; ++i) {
1458 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
1459 "pmix20_bfrop_unpack: init array[%d]", i);
1460 memset(&ptr[i], 0, sizeof(pmix_info_array_t));
1461
1462 m=1;
1463 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_sizet(regtypes, buffer, &ptr[i].size, &m, PMIX_SIZE))) {
1464 return ret;
1465 }
1466 if (0 < ptr[i].size) {
1467 ptr[i].array = (pmix_info_t*)malloc(ptr[i].size * sizeof(pmix_info_t));
1468 m=ptr[i].size;
1469 if (PMIX_SUCCESS != (ret = pmix20_bfrop_unpack_value(regtypes, buffer, ptr[i].array, &m, PMIX_INFO))) {
1470 return ret;
1471 }
1472 }
1473 }
1474 return PMIX_SUCCESS;
1475 }
1476