This source file includes following definitions.
- pmix12_bfrop_unpack
- pmix12_bfrop_unpack_buffer
- pmix12_bfrop_unpack_bool
- pmix12_bfrop_unpack_int
- pmix12_bfrop_unpack_sizet
- pmix12_bfrop_unpack_pid
- pmix12_bfrop_unpack_byte
- pmix12_bfrop_unpack_int16
- pmix12_bfrop_unpack_int32
- pmix12_bfrop_unpack_datatype
- pmix12_bfrop_unpack_int64
- pmix12_bfrop_unpack_string
- pmix12_bfrop_unpack_float
- pmix12_bfrop_unpack_double
- pmix12_bfrop_unpack_timeval
- pmix12_bfrop_unpack_time
- unpack_val
- pmix12_bfrop_unpack_value
- pmix12_bfrop_unpack_info
- pmix12_bfrop_unpack_pdata
- pmix12_bfrop_unpack_buf
- pmix12_bfrop_unpack_proc
- pmix12_bfrop_unpack_app
- pmix12_bfrop_unpack_kval
- pmix12_bfrop_unpack_array
- pmix12_bfrop_unpack_modex
- pmix12_bfrop_unpack_persist
- pmix12_bfrop_unpack_bo
- pmix12_bfrop_unpack_ptr
- pmix12_bfrop_unpack_scope
- pmix12_bfrop_unpack_status
- pmix12_bfrop_unpack_range
- pmix12_bfrop_unpack_cmd
- pmix12_bfrop_unpack_info_directives
- pmix12_bfrop_unpack_proc_state
- pmix12_bfrop_unpack_darray
- pmix12_bfrop_unpack_proc_info
- pmix12_bfrop_unpack_query
- pmix12_bfrop_unpack_rank
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_v12.h"
33 #include "internal.h"
34
35 pmix_status_t pmix12_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_v12_component.types;
43
44 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
45 "pmix12_bfrop_unpack: for type %d", (int)type);
46
47
48 if (NULL == buffer || NULL == dst || NULL == num_vals) {
49 PMIX_ERROR_LOG(PMIX_ERR_BAD_PARAM);
50 return PMIX_ERR_BAD_PARAM;
51 }
52
53
54
55
56 if (0 == *num_vals) {
57 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
58 "pmix12_bfrop_unpack: inadequate space ( %p, %p, %lu, %d )\n",
59 (void*)buffer, dst, (long unsigned int)*num_vals, (int)type);
60 PMIX_ERROR_LOG(PMIX_ERR_UNPACK_INADEQUATE_SPACE);
61 return PMIX_ERR_UNPACK_INADEQUATE_SPACE;
62 }
63
64
65
66
67
68
69
70
71
72
73 if (PMIX_BFROP_BUFFER_FULLY_DESC == buffer->type) {
74 if (PMIX_SUCCESS != (rc = pmix12_bfrop_get_data_type(regtypes, buffer, &local_type))) {
75 *num_vals = 0;
76
77
78 return rc;
79 }
80 if (PMIX_INT32 != local_type) {
81 *num_vals = 0;
82 PMIX_ERROR_LOG(PMIX_ERR_UNPACK_FAILURE);
83 return PMIX_ERR_UNPACK_FAILURE;
84 }
85 }
86
87 n=1;
88 if (PMIX_SUCCESS != (rc = pmix12_bfrop_unpack_int32(regtypes, buffer, &local_num, &n, PMIX_INT32))) {
89 *num_vals = 0;
90
91
92 PMIX_ERROR_LOG(rc);
93 return rc;
94 }
95
96 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
97 "pmix12_bfrop_unpack: found %d values for %d provided storage",
98 local_num, *num_vals);
99
100
101
102
103
104
105 if (local_num > *num_vals) {
106 local_num = *num_vals;
107 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
108 "pmix12_bfrop_unpack: inadequate space ( %p, %p, %lu, %d )\n",
109 (void*)buffer, dst, (long unsigned int)*num_vals, (int)type);
110 ret = PMIX_ERR_UNPACK_INADEQUATE_SPACE;
111 } else {
112 *num_vals = local_num;
113 ret = PMIX_SUCCESS;
114 }
115
116
117 if (PMIX_SUCCESS != (rc = pmix12_bfrop_unpack_buffer(regtypes, buffer, dst, &local_num, type))) {
118 PMIX_ERROR_LOG(rc);
119 *num_vals = 0;
120 ret = rc;
121 }
122
123 return ret;
124 }
125
126 pmix_status_t pmix12_bfrop_unpack_buffer(pmix_pointer_array_t *regtypes,
127 pmix_buffer_t *buffer, void *dst, int32_t *num_vals,
128 pmix_data_type_t type)
129 {
130 pmix_status_t rc;
131 pmix_data_type_t local_type, v1type;
132
133 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output, "pmix12_bfrop_unpack_buffer( %p, %p, %lu, %d )\n",
134 (void*)buffer, dst, (long unsigned int)*num_vals, (int)type);
135
136
137 switch (type) {
138 case PMIX_COMMAND:
139 v1type = PMIX_UINT32;
140 break;
141 case PMIX_SCOPE:
142 case PMIX_DATA_RANGE:
143 v1type = PMIX_UINT;
144 break;
145 case PMIX_PROC_RANK:
146 case PMIX_PERSIST:
147 case PMIX_STATUS:
148 v1type = PMIX_INT;
149 break;
150 default:
151 v1type = type;
152 }
153
154
155 if (PMIX_BFROP_BUFFER_FULLY_DESC == buffer->type) {
156 if (PMIX_SUCCESS != (rc = pmix12_bfrop_get_data_type(regtypes, buffer, &local_type))) {
157 PMIX_ERROR_LOG(rc);
158 return rc;
159 }
160
161 if (v1type != local_type) {
162 pmix_output_verbose(1, pmix_bfrops_base_framework.framework_output,
163 "PMIX bfrop:unpack: got type %d when expecting type %d", local_type, v1type);
164 return PMIX_ERR_PACK_MISMATCH;
165 }
166 }
167 PMIX_BFROPS_UNPACK_TYPE(rc, buffer, dst, num_vals, v1type, regtypes);
168
169 return rc;
170 }
171
172
173
174
175
176
177
178 pmix_status_t pmix12_bfrop_unpack_bool(pmix_pointer_array_t *regtypes,
179 pmix_buffer_t *buffer, void *dest,
180 int32_t *num_vals, pmix_data_type_t type)
181 {
182 int32_t i;
183 uint8_t *src;
184 bool *dst;
185
186 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output, "pmix12_bfrop_unpack_bool * %d\n", (int)*num_vals);
187
188 if (pmix_bfrop_too_small(buffer, *num_vals)) {
189 return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
190 }
191
192
193 src = (uint8_t*)buffer->unpack_ptr;
194 dst = (bool*)dest;
195
196 for (i=0; i < *num_vals; i++) {
197 if (src[i]) {
198 dst[i] = true;
199 } else {
200 dst[i] = false;
201 }
202 }
203
204
205 buffer->unpack_ptr += *num_vals;
206
207 return PMIX_SUCCESS;
208 }
209
210
211
212
213 pmix_status_t pmix12_bfrop_unpack_int(pmix_pointer_array_t *regtypes,
214 pmix_buffer_t *buffer, void *dest,
215 int32_t *num_vals, pmix_data_type_t type)
216 {
217 pmix_status_t ret;
218 pmix_data_type_t remote_type;
219
220 if (PMIX_SUCCESS != (ret = pmix12_bfrop_get_data_type(regtypes, buffer, &remote_type))) {
221 return ret;
222 }
223
224 if (remote_type == BFROP_TYPE_INT) {
225
226
227 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, dest, num_vals, BFROP_TYPE_INT))) {
228 }
229 } else {
230
231 PMIX_BFROP_UNPACK_SIZE_MISMATCH(regtypes, int, remote_type, ret);
232 }
233
234 return ret;
235 }
236
237
238
239
240 pmix_status_t pmix12_bfrop_unpack_sizet(pmix_pointer_array_t *regtypes,
241 pmix_buffer_t *buffer, void *dest,
242 int32_t *num_vals, pmix_data_type_t type)
243 {
244 pmix_status_t ret;
245 pmix_data_type_t remote_type;
246
247 if (PMIX_SUCCESS != (ret = pmix12_bfrop_get_data_type(regtypes, buffer, &remote_type))) {
248 return ret;
249 }
250
251 if (remote_type == BFROP_TYPE_SIZE_T) {
252
253
254 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, dest, num_vals, BFROP_TYPE_SIZE_T))) {
255 }
256 } else {
257
258 PMIX_BFROP_UNPACK_SIZE_MISMATCH(regtypes, size_t, remote_type, ret);
259 }
260
261 return ret;
262 }
263
264
265
266
267 pmix_status_t pmix12_bfrop_unpack_pid(pmix_pointer_array_t *regtypes,
268 pmix_buffer_t *buffer, void *dest,
269 int32_t *num_vals, pmix_data_type_t type)
270 {
271 pmix_status_t ret;
272 pmix_data_type_t remote_type;
273
274 if (PMIX_SUCCESS != (ret = pmix12_bfrop_get_data_type(regtypes, buffer, &remote_type))) {
275 return ret;
276 }
277
278 if (remote_type == BFROP_TYPE_PID_T) {
279
280
281 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, dest, num_vals, BFROP_TYPE_PID_T))) {
282 }
283 } else {
284
285 PMIX_BFROP_UNPACK_SIZE_MISMATCH(regtypes, pid_t, remote_type, ret);
286 }
287
288 return ret;
289 }
290
291
292
293
294
295
296
297 pmix_status_t pmix12_bfrop_unpack_byte(pmix_pointer_array_t *regtypes,
298 pmix_buffer_t *buffer, void *dest,
299 int32_t *num_vals, pmix_data_type_t type)
300 {
301 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output, "pmix12_bfrop_unpack_byte * %d\n", (int)*num_vals);
302
303 if (pmix_bfrop_too_small(buffer, *num_vals)) {
304 return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
305 }
306
307
308 memcpy(dest, buffer->unpack_ptr, *num_vals);
309
310
311 buffer->unpack_ptr += *num_vals;
312
313 return PMIX_SUCCESS;
314 }
315
316 pmix_status_t pmix12_bfrop_unpack_int16(pmix_pointer_array_t *regtypes,
317 pmix_buffer_t *buffer, void *dest,
318 int32_t *num_vals, pmix_data_type_t type)
319 {
320 int32_t i;
321 uint16_t tmp, *desttmp = (uint16_t*) dest;
322
323 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output, "pmix12_bfrop_unpack_int16 * %d\n", (int)*num_vals);
324
325 if (pmix_bfrop_too_small(buffer, (*num_vals)*sizeof(tmp))) {
326 return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
327 }
328
329
330 for (i = 0; i < (*num_vals); ++i) {
331 memcpy( &(tmp), buffer->unpack_ptr, sizeof(tmp) );
332 tmp = pmix_ntohs(tmp);
333 memcpy(&desttmp[i], &tmp, sizeof(tmp));
334 buffer->unpack_ptr += sizeof(tmp);
335 }
336
337 return PMIX_SUCCESS;
338 }
339
340 pmix_status_t pmix12_bfrop_unpack_int32(pmix_pointer_array_t *regtypes,
341 pmix_buffer_t *buffer, void *dest,
342 int32_t *num_vals, pmix_data_type_t type)
343 {
344 int32_t i;
345 uint32_t tmp, *desttmp = (uint32_t*) dest;
346
347 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output, "pmix12_bfrop_unpack_int32 * %d\n", (int)*num_vals);
348
349 if (pmix_bfrop_too_small(buffer, (*num_vals)*sizeof(tmp))) {
350 return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
351 }
352
353
354 for (i = 0; i < (*num_vals); ++i) {
355 memcpy( &(tmp), buffer->unpack_ptr, sizeof(tmp) );
356 tmp = ntohl(tmp);
357 memcpy(&desttmp[i], &tmp, sizeof(tmp));
358 buffer->unpack_ptr += sizeof(tmp);
359 }
360
361 return PMIX_SUCCESS;
362 }
363
364 pmix_status_t pmix12_bfrop_unpack_datatype(pmix_pointer_array_t *regtypes,
365 pmix_buffer_t *buffer, void *dest,
366 int32_t *num_vals, pmix_data_type_t type)
367 {
368 return pmix12_bfrop_unpack_int32(regtypes, buffer, dest, num_vals, type);
369 }
370
371 pmix_status_t pmix12_bfrop_unpack_int64(pmix_pointer_array_t *regtypes,
372 pmix_buffer_t *buffer, void *dest,
373 int32_t *num_vals, pmix_data_type_t type)
374 {
375 int32_t i;
376 uint64_t tmp, *desttmp = (uint64_t*) dest;
377
378 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
379 "pmix12_bfrop_unpack_int64 * %d\n", (int)*num_vals);
380
381 if (pmix_bfrop_too_small(buffer, (*num_vals)*sizeof(tmp))) {
382 return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
383 }
384
385
386 for (i = 0; i < (*num_vals); ++i) {
387 memcpy( &(tmp), buffer->unpack_ptr, sizeof(tmp) );
388 tmp = pmix_ntoh64(tmp);
389 memcpy(&desttmp[i], &tmp, sizeof(tmp));
390 buffer->unpack_ptr += sizeof(tmp);
391 }
392
393 return PMIX_SUCCESS;
394 }
395
396 pmix_status_t pmix12_bfrop_unpack_string(pmix_pointer_array_t *regtypes,
397 pmix_buffer_t *buffer, void *dest,
398 int32_t *num_vals, pmix_data_type_t type)
399 {
400 pmix_status_t ret;
401 int32_t i, len, n=1;
402 char **sdest = (char**) dest;
403
404 for (i = 0; i < (*num_vals); ++i) {
405 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_int32(regtypes, buffer,
406 &len, &n, PMIX_INT32))) {
407 return ret;
408 }
409 if (0 == len) {
410 sdest[i] = NULL;
411 } else {
412 sdest[i] = (char*)malloc(len);
413 if (NULL == sdest[i]) {
414 return PMIX_ERR_OUT_OF_RESOURCE;
415 }
416 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_byte(regtypes, buffer,
417 sdest[i], &len,
418 PMIX_BYTE))) {
419 return ret;
420 }
421 }
422 }
423
424 return PMIX_SUCCESS;
425 }
426
427 pmix_status_t pmix12_bfrop_unpack_float(pmix_pointer_array_t *regtypes,
428 pmix_buffer_t *buffer, void *dest,
429 int32_t *num_vals, pmix_data_type_t type)
430 {
431 int32_t i, n;
432 float *desttmp = (float*) dest, tmp;
433 pmix_status_t ret;
434 char *convert;
435
436 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
437 "pmix12_bfrop_unpack_float * %d\n", (int)*num_vals);
438
439 if (pmix_bfrop_too_small(buffer, (*num_vals)*sizeof(float))) {
440 return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
441 }
442
443
444 for (i = 0; i < (*num_vals); ++i) {
445 n=1;
446 convert = NULL;
447 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_string(regtypes, buffer,
448 &convert, &n, PMIX_STRING))) {
449 return ret;
450 }
451 if (NULL != convert) {
452 tmp = strtof(convert, NULL);
453 memcpy(&desttmp[i], &tmp, sizeof(tmp));
454 free(convert);
455 }
456 }
457 return PMIX_SUCCESS;
458 }
459
460 pmix_status_t pmix12_bfrop_unpack_double(pmix_pointer_array_t *regtypes,
461 pmix_buffer_t *buffer, void *dest,
462 int32_t *num_vals, pmix_data_type_t type)
463 {
464 int32_t i, n;
465 double *desttmp = (double*) dest, tmp;
466 pmix_status_t ret;
467 char *convert;
468
469 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
470 "pmix12_bfrop_unpack_double * %d\n", (int)*num_vals);
471
472 if (pmix_bfrop_too_small(buffer, (*num_vals)*sizeof(double))) {
473 return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
474 }
475
476
477 for (i = 0; i < (*num_vals); ++i) {
478 n=1;
479 convert = NULL;
480 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_string(regtypes, buffer,
481 &convert, &n,
482 PMIX_STRING))) {
483 return ret;
484 }
485 if (NULL != convert) {
486 tmp = strtod(convert, NULL);
487 memcpy(&desttmp[i], &tmp, sizeof(tmp));
488 free(convert);
489 }
490 }
491 return PMIX_SUCCESS;
492 }
493
494 pmix_status_t pmix12_bfrop_unpack_timeval(pmix_pointer_array_t *regtypes,
495 pmix_buffer_t *buffer, void *dest,
496 int32_t *num_vals, pmix_data_type_t type)
497 {
498 int32_t i, n;
499 int64_t tmp[2];
500 struct timeval *desttmp = (struct timeval *) dest, tt;
501 pmix_status_t ret;
502
503 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
504 "pmix12_bfrop_unpack_timeval * %d\n", (int)*num_vals);
505
506 if (pmix_bfrop_too_small(buffer, (*num_vals)*sizeof(struct timeval))) {
507 return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
508 }
509
510
511 for (i = 0; i < (*num_vals); ++i) {
512 n=2;
513 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_int64(regtypes, buffer,
514 tmp, &n, PMIX_INT64))) {
515 return ret;
516 }
517 tt.tv_sec = tmp[0];
518 tt.tv_usec = tmp[1];
519 memcpy(&desttmp[i], &tt, sizeof(tt));
520 }
521 return PMIX_SUCCESS;
522 }
523
524 pmix_status_t pmix12_bfrop_unpack_time(pmix_pointer_array_t *regtypes,
525 pmix_buffer_t *buffer, void *dest,
526 int32_t *num_vals, pmix_data_type_t type)
527 {
528 int32_t i, n;
529 time_t *desttmp = (time_t *) dest, tmp;
530 pmix_status_t ret;
531 uint64_t ui64;
532
533
534
535
536
537 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
538 "pmix12_bfrop_unpack_time * %d\n", (int)*num_vals);
539
540 if (pmix_bfrop_too_small(buffer, (*num_vals)*(sizeof(uint64_t)))) {
541 return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
542 }
543
544
545 for (i = 0; i < (*num_vals); ++i) {
546 n=1;
547 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_int64(regtypes, buffer,
548 &ui64, &n, PMIX_UINT64))) {
549 return ret;
550 }
551 tmp = (time_t)ui64;
552 memcpy(&desttmp[i], &tmp, sizeof(tmp));
553 }
554 return PMIX_SUCCESS;
555 }
556
557
558
559
560
561
562
563 static pmix_status_t unpack_val(pmix_pointer_array_t *regtypes,
564 pmix_buffer_t *buffer, pmix_value_t *val)
565 {
566 int32_t m;
567 pmix_status_t ret;
568
569 m = 1;
570 switch (val->type) {
571 case PMIX_BOOL:
572 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.flag, &m, PMIX_BOOL))) {
573 return ret;
574 }
575 break;
576 case PMIX_BYTE:
577 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.byte, &m, PMIX_BYTE))) {
578 return ret;
579 }
580 break;
581 case PMIX_STRING:
582 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.string, &m, PMIX_STRING))) {
583 return ret;
584 }
585 break;
586 case PMIX_SIZE:
587 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.size, &m, PMIX_SIZE))) {
588 return ret;
589 }
590 break;
591 case PMIX_PID:
592 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.pid, &m, PMIX_PID))) {
593 return ret;
594 }
595 break;
596 case PMIX_INT:
597 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.integer, &m, PMIX_INT))) {
598 return ret;
599 }
600 break;
601 case PMIX_INT8:
602 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.int8, &m, PMIX_INT8))) {
603 return ret;
604 }
605 break;
606 case PMIX_INT16:
607 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.int16, &m, PMIX_INT16))) {
608 return ret;
609 }
610 break;
611 case PMIX_INT32:
612 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.int32, &m, PMIX_INT32))) {
613 return ret;
614 }
615 break;
616 case PMIX_INT64:
617 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.int64, &m, PMIX_INT64))) {
618 return ret;
619 }
620 break;
621 case PMIX_UINT:
622 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.uint, &m, PMIX_UINT))) {
623 return ret;
624 }
625 break;
626 case PMIX_UINT8:
627 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.uint8, &m, PMIX_UINT8))) {
628 return ret;
629 }
630 break;
631 case PMIX_UINT16:
632 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.uint16, &m, PMIX_UINT16))) {
633 return ret;
634 }
635 break;
636 case PMIX_UINT32:
637 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.uint32, &m, PMIX_UINT32))) {
638 return ret;
639 }
640 break;
641 case PMIX_UINT64:
642 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.uint64, &m, PMIX_UINT64))) {
643 return ret;
644 }
645 break;
646 case PMIX_FLOAT:
647 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.fval, &m, PMIX_FLOAT))) {
648 return ret;
649 }
650 break;
651 case PMIX_DOUBLE:
652 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.dval, &m, PMIX_DOUBLE))) {
653 return ret;
654 }
655 break;
656 case PMIX_TIMEVAL:
657 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.tv, &m, PMIX_TIMEVAL))) {
658 return ret;
659 }
660 break;
661 case PMIX_INFO_ARRAY:
662
663
664 val->data.darray = (pmix_data_array_t*)calloc(1, sizeof(pmix_data_array_t));
665 val->data.darray->type = PMIX_INFO_ARRAY;
666 val->data.darray->size = m;
667
668 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.darray->array, &m, PMIX_INFO_ARRAY))) {
669 return ret;
670 }
671 break;
672 case PMIX_BYTE_OBJECT:
673 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.bo, &m, PMIX_BYTE_OBJECT))) {
674 return ret;
675 }
676 break;
677 default:
678 pmix_output(0, "UNPACK-PMIX-VALUE: UNSUPPORTED TYPE");
679 return PMIX_ERROR;
680 }
681
682 return PMIX_SUCCESS;
683 }
684
685 pmix_status_t pmix12_bfrop_unpack_value(pmix_pointer_array_t *regtypes,
686 pmix_buffer_t *buffer, void *dest,
687 int32_t *num_vals, pmix_data_type_t type)
688 {
689 pmix_value_t *ptr;
690 int32_t i, m, n;
691 pmix_status_t ret;
692 int v1type;
693
694 ptr = (pmix_value_t *) dest;
695 n = *num_vals;
696
697 for (i = 0; i < n; ++i) {
698
699 m=1;
700 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_int(regtypes, buffer, &v1type, &m, PMIX_INT))) {
701 return ret;
702 }
703
704
705
706 ptr[i].type = pmix12_v1_to_v2_datatype(v1type);
707
708 if (PMIX_SUCCESS != (ret = unpack_val(regtypes, buffer, &ptr[i])) ) {
709 return ret;
710 }
711 }
712 return PMIX_SUCCESS;
713 }
714
715 pmix_status_t pmix12_bfrop_unpack_info(pmix_pointer_array_t *regtypes,
716 pmix_buffer_t *buffer, void *dest,
717 int32_t *num_vals, pmix_data_type_t type)
718 {
719 pmix_info_t *ptr;
720 int32_t i, n, m;
721 pmix_status_t ret;
722 char *tmp;
723 int v1type;
724
725 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
726 "pmix12_bfrop_unpack: %d info", *num_vals);
727
728 ptr = (pmix_info_t *) dest;
729 n = *num_vals;
730
731 for (i = 0; i < n; ++i) {
732 memset(ptr[i].key, 0, sizeof(ptr[i].key));
733 memset(&ptr[i].value, 0, sizeof(pmix_value_t));
734
735 m=1;
736 tmp = NULL;
737 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_string(regtypes, buffer, &tmp, &m, PMIX_STRING))) {
738 return ret;
739 }
740 if (NULL == tmp) {
741 return PMIX_ERROR;
742 }
743 pmix_strncpy(ptr[i].key, tmp, PMIX_MAX_KEYLEN);
744 free(tmp);
745
746
747
748 m=1;
749 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_int(regtypes, buffer, &v1type, &m, PMIX_INT))) {
750 return ret;
751 }
752
753
754
755 ptr[i].value.type = pmix12_v1_to_v2_datatype(v1type);
756 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
757 "pmix12_bfrop_unpack: info type %d", ptr[i].value.type);
758 m=1;
759 if (PMIX_SUCCESS != (ret = unpack_val(regtypes, buffer, &ptr[i].value))) {
760 return ret;
761 }
762 }
763 return PMIX_SUCCESS;
764 }
765
766 pmix_status_t pmix12_bfrop_unpack_pdata(pmix_pointer_array_t *regtypes,
767 pmix_buffer_t *buffer, void *dest,
768 int32_t *num_vals, pmix_data_type_t type)
769 {
770 pmix_pdata_t *ptr;
771 int32_t i, n, m;
772 pmix_status_t ret;
773 char *tmp;
774 int v1type;
775
776 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
777 "pmix12_bfrop_unpack: %d pdata", *num_vals);
778
779 ptr = (pmix_pdata_t *) dest;
780 n = *num_vals;
781
782 for (i = 0; i < n; ++i) {
783 PMIX_PDATA_CONSTRUCT(&ptr[i]);
784
785 m=1;
786 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_proc(regtypes, buffer, &ptr[i].proc, &m, PMIX_PROC))) {
787 return ret;
788 }
789
790 m=1;
791 tmp = NULL;
792 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_string(regtypes, buffer, &tmp, &m, PMIX_STRING))) {
793 return ret;
794 }
795 if (NULL == tmp) {
796 return PMIX_ERROR;
797 }
798 pmix_strncpy(ptr[i].key, tmp, PMIX_MAX_KEYLEN);
799 free(tmp);
800
801
802
803 m=1;
804 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_int(regtypes, buffer, &v1type, &m, PMIX_INT))) {
805 return ret;
806 }
807
808
809
810 ptr[i].value.type = pmix12_v1_to_v2_datatype(v1type);
811 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
812 "pmix12_bfrop_unpack: pdata type %d", ptr[i].value.type);
813 m=1;
814 if (PMIX_SUCCESS != (ret = unpack_val(regtypes, buffer, &ptr[i].value))) {
815 return ret;
816 }
817 }
818 return PMIX_SUCCESS;
819 }
820
821 pmix_status_t pmix12_bfrop_unpack_buf(pmix_pointer_array_t *regtypes,
822 pmix_buffer_t *buffer, void *dest,
823 int32_t *num_vals, pmix_data_type_t type)
824 {
825 pmix_buffer_t *ptr;
826 int32_t i, n, m;
827 pmix_status_t ret;
828 size_t nbytes;
829
830 ptr = (pmix_buffer_t *) dest;
831 n = *num_vals;
832
833 for (i = 0; i < n; ++i) {
834
835 m=1;
836 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_sizet(regtypes, buffer, &nbytes, &m, PMIX_SIZE))) {
837 return ret;
838 }
839 m = nbytes;
840
841 if (0 < nbytes) {
842 ptr[i].base_ptr = (char*)malloc(nbytes);
843
844 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_byte(regtypes, buffer, ptr[i].base_ptr, &m, PMIX_BYTE))) {
845 return ret;
846 }
847 }
848 ptr[i].pack_ptr = ptr[i].base_ptr + m;
849 ptr[i].unpack_ptr = ptr[i].base_ptr;
850 ptr[i].bytes_allocated = nbytes;
851 ptr[i].bytes_used = m;
852 }
853 return PMIX_SUCCESS;
854 }
855
856 pmix_status_t pmix12_bfrop_unpack_proc(pmix_pointer_array_t *regtypes,
857 pmix_buffer_t *buffer, void *dest,
858 int32_t *num_vals, pmix_data_type_t type)
859 {
860 pmix_proc_t *ptr;
861 int32_t i, n, m;
862 pmix_status_t ret;
863 char *tmp;
864
865 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
866 "pmix12_bfrop_unpack: %d procs", *num_vals);
867
868 ptr = (pmix_proc_t *) dest;
869 n = *num_vals;
870
871 for (i = 0; i < n; ++i) {
872 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
873 "pmix12_bfrop_unpack: init proc[%d]", i);
874 memset(&ptr[i], 0, sizeof(pmix_proc_t));
875
876 m=1;
877 tmp = NULL;
878 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_string(regtypes, buffer, &tmp, &m, PMIX_STRING))) {
879 return ret;
880 }
881 if (NULL == tmp) {
882 return PMIX_ERROR;
883 }
884 pmix_strncpy(ptr[i].nspace, tmp, PMIX_MAX_NSLEN);
885 free(tmp);
886
887 m=1;
888 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_int(regtypes, buffer, &ptr[i].rank, &m, PMIX_INT))) {
889 return ret;
890 }
891
892
893 if (INT32_MAX == ptr[i].rank) {
894 ptr[i].rank = PMIX_RANK_UNDEF;
895 } else if (INT32_MAX-1 == ptr[i].rank) {
896 ptr[i].rank = PMIX_RANK_WILDCARD;
897 }
898 }
899 return PMIX_SUCCESS;
900 }
901
902 pmix_status_t pmix12_bfrop_unpack_app(pmix_pointer_array_t *regtypes,
903 pmix_buffer_t *buffer, void *dest,
904 int32_t *num_vals, pmix_data_type_t type)
905 {
906 pmix_app_t *ptr;
907 int32_t i, k, n, m;
908 pmix_status_t ret;
909 int32_t nval;
910 char *tmp;
911 int argc;
912
913 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
914 "pmix12_bfrop_unpack: %d apps", *num_vals);
915
916 ptr = (pmix_app_t *) dest;
917 n = *num_vals;
918
919 for (i = 0; i < n; ++i) {
920
921 PMIX_APP_CONSTRUCT(&ptr[i]);
922
923 m=1;
924 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_string(regtypes, buffer, &ptr[i].cmd, &m, PMIX_STRING))) {
925 return ret;
926 }
927
928 m=1;
929 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_int(regtypes, buffer, &argc, &m, PMIX_INT))) {
930 return ret;
931 }
932
933 for (k=0; k < argc; k++) {
934 m=1;
935 tmp = NULL;
936 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_string(regtypes, buffer, &tmp, &m, PMIX_STRING))) {
937 return ret;
938 }
939 if (NULL == tmp) {
940 return PMIX_ERROR;
941 }
942 pmix_argv_append_nosize(&ptr[i].argv, tmp);
943 free(tmp);
944 }
945
946 m=1;
947 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_int32(regtypes, buffer, &nval, &m, PMIX_INT32))) {
948 return ret;
949 }
950 for (k=0; k < nval; k++) {
951 m=1;
952 tmp = NULL;
953 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_string(regtypes, buffer, &tmp, &m, PMIX_STRING))) {
954 return ret;
955 }
956 if (NULL == tmp) {
957 return PMIX_ERROR;
958 }
959 pmix_argv_append_nosize(&ptr[i].env, tmp);
960 free(tmp);
961 }
962
963 m=1;
964 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_int(regtypes, buffer, &ptr[i].maxprocs, &m, PMIX_INT))) {
965 return ret;
966 }
967
968 m=1;
969 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_sizet(regtypes, buffer, &ptr[i].ninfo, &m, PMIX_SIZE))) {
970 return ret;
971 }
972 if (0 < ptr[i].ninfo) {
973 PMIX_INFO_CREATE(ptr[i].info, ptr[i].ninfo);
974 m = ptr[i].ninfo;
975 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_info(regtypes, buffer, ptr[i].info, &m, PMIX_INFO))) {
976 return ret;
977 }
978 }
979 }
980 return PMIX_SUCCESS;
981 }
982
983 pmix_status_t pmix12_bfrop_unpack_kval(pmix_pointer_array_t *regtypes,
984 pmix_buffer_t *buffer, void *dest,
985 int32_t *num_vals, pmix_data_type_t type)
986 {
987 pmix_kval_t *ptr;
988 int32_t i, n, m;
989 pmix_status_t ret;
990
991 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
992 "pmix12_bfrop_unpack: %d kvals", *num_vals);
993
994 ptr = (pmix_kval_t*) dest;
995 n = *num_vals;
996
997 for (i = 0; i < n; ++i) {
998 PMIX_CONSTRUCT(&ptr[i], pmix_kval_t);
999
1000 m = 1;
1001 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_string(regtypes, buffer, &ptr[i].key, &m, PMIX_STRING))) {
1002 PMIX_ERROR_LOG(ret);
1003 return ret;
1004 }
1005
1006 ptr[i].value = (pmix_value_t*)malloc(sizeof(pmix_value_t));
1007
1008 m = 1;
1009 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_value(regtypes, buffer, ptr[i].value, &m, PMIX_VALUE))) {
1010 PMIX_ERROR_LOG(ret);
1011 return ret;
1012 }
1013 }
1014 return PMIX_SUCCESS;
1015 }
1016
1017 pmix_status_t pmix12_bfrop_unpack_array(pmix_pointer_array_t *regtypes,
1018 pmix_buffer_t *buffer, void *dest,
1019 int32_t *num_vals, pmix_data_type_t type)
1020 {
1021 pmix_info_array_t *ptr;
1022 int32_t i, n, m;
1023 pmix_status_t ret;
1024
1025 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
1026 "pmix12_bfrop_unpack: %d info arrays", *num_vals);
1027
1028 ptr = (pmix_info_array_t*) dest;
1029 n = *num_vals;
1030
1031 for (i = 0; i < n; ++i) {
1032 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
1033 "pmix12_bfrop_unpack: init array[%d]", i);
1034 memset(&ptr[i], 0, sizeof(pmix_info_array_t));
1035
1036 m=1;
1037 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_sizet(regtypes, buffer, &ptr[i].size, &m, PMIX_SIZE))) {
1038 return ret;
1039 }
1040 if (0 < ptr[i].size) {
1041 ptr[i].array = (pmix_info_t*)malloc(ptr[i].size * sizeof(pmix_info_t));
1042 m=ptr[i].size;
1043 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_value(regtypes, buffer, ptr[i].array, &m, PMIX_INFO))) {
1044 return ret;
1045 }
1046 }
1047 }
1048 return PMIX_SUCCESS;
1049 }
1050
1051 pmix_status_t pmix12_bfrop_unpack_modex(pmix_pointer_array_t *regtypes,
1052 pmix_buffer_t *buffer, void *dest,
1053 int32_t *num_vals, pmix_data_type_t type)
1054 {
1055 pmix_modex_data_t *ptr;
1056 int32_t i, n, m;
1057 pmix_status_t ret;
1058
1059 pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
1060 "pmix12_bfrop_unpack: %d modex", *num_vals);
1061
1062 ptr = (pmix_modex_data_t *) dest;
1063 n = *num_vals;
1064
1065 for (i = 0; i < n; ++i) {
1066 memset(&ptr[i], 0, sizeof(pmix_modex_data_t));
1067
1068 m=1;
1069 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_sizet(regtypes, buffer, &ptr[i].size, &m, PMIX_SIZE))) {
1070 return ret;
1071 }
1072 if (0 < ptr[i].size) {
1073 ptr[i].blob = (uint8_t*)malloc(ptr[i].size * sizeof(uint8_t));
1074 m=ptr[i].size;
1075 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_byte(regtypes, buffer, ptr[i].blob, &m, PMIX_UINT8))) {
1076 return ret;
1077 }
1078 }
1079 }
1080 return PMIX_SUCCESS;
1081 }
1082
1083
1084 pmix_status_t pmix12_bfrop_unpack_persist(pmix_pointer_array_t *regtypes,
1085 pmix_buffer_t *buffer, void *dest,
1086 int32_t *num_vals, pmix_data_type_t type)
1087 {
1088 return pmix12_bfrop_unpack_int(regtypes, buffer, dest, num_vals, PMIX_INT);
1089 }
1090
1091 pmix_status_t pmix12_bfrop_unpack_bo(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_byte_object_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 "pmix12_bfrop_unpack: %d byte_object", *num_vals);
1101
1102 ptr = (pmix_byte_object_t *) dest;
1103 n = *num_vals;
1104
1105 for (i = 0; i < n; ++i) {
1106 memset(&ptr[i], 0, sizeof(pmix_byte_object_t));
1107
1108 m=1;
1109 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_sizet(regtypes, buffer, &ptr[i].size, &m, PMIX_SIZE))) {
1110 return ret;
1111 }
1112 if (0 < ptr[i].size) {
1113 ptr[i].bytes = (char*)malloc(ptr[i].size * sizeof(char));
1114 m=ptr[i].size;
1115 if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_byte(regtypes, buffer, ptr[i].bytes, &m, PMIX_BYTE))) {
1116 return ret;
1117 }
1118 }
1119 }
1120 return PMIX_SUCCESS;
1121 }
1122
1123 pmix_status_t pmix12_bfrop_unpack_ptr(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 PMIX_ERR_NOT_SUPPORTED;
1128 }
1129
1130 pmix_status_t pmix12_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 PMIX_ERR_NOT_SUPPORTED;
1135 }
1136
1137 pmix_status_t pmix12_bfrop_unpack_status(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 PMIX_ERR_NOT_SUPPORTED;
1142 }
1143
1144 pmix_status_t pmix12_bfrop_unpack_range(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 PMIX_ERR_NOT_SUPPORTED;
1149 }
1150
1151 pmix_status_t pmix12_bfrop_unpack_cmd(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 PMIX_ERR_NOT_SUPPORTED;
1156 }
1157
1158 pmix_status_t pmix12_bfrop_unpack_info_directives(pmix_pointer_array_t *regtypes,
1159 pmix_buffer_t *buffer, void *dest,
1160 int32_t *num_vals, pmix_data_type_t type)
1161 {
1162 return PMIX_ERR_NOT_SUPPORTED;
1163 }
1164
1165 pmix_status_t pmix12_bfrop_unpack_proc_state(pmix_pointer_array_t *regtypes,
1166 pmix_buffer_t *buffer, void *dest,
1167 int32_t *num_vals, pmix_data_type_t type)
1168 {
1169 return PMIX_ERR_NOT_SUPPORTED;
1170 }
1171
1172 pmix_status_t pmix12_bfrop_unpack_darray(pmix_pointer_array_t *regtypes,
1173 pmix_buffer_t *buffer, void *dest,
1174 int32_t *num_vals, pmix_data_type_t type)
1175 {
1176 return PMIX_ERR_NOT_SUPPORTED;
1177 }
1178
1179 pmix_status_t pmix12_bfrop_unpack_proc_info(pmix_pointer_array_t *regtypes,
1180 pmix_buffer_t *buffer, void *dest,
1181 int32_t *num_vals, pmix_data_type_t type)
1182 {
1183 return PMIX_ERR_NOT_SUPPORTED;
1184 }
1185
1186 pmix_status_t pmix12_bfrop_unpack_query(pmix_pointer_array_t *regtypes,
1187 pmix_buffer_t *buffer, void *dest,
1188 int32_t *num_vals, pmix_data_type_t type)
1189 {
1190 return PMIX_ERR_NOT_SUPPORTED;
1191 }
1192
1193 pmix_status_t pmix12_bfrop_unpack_rank(pmix_pointer_array_t *regtypes,
1194 pmix_buffer_t *buffer, void *dest,
1195 int32_t *num_vals, pmix_data_type_t type)
1196 {
1197 return PMIX_ERR_NOT_SUPPORTED;
1198 }