1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 2014 Gary Mills
24 *
25 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
26 * Use is subject to license terms.
27 *
28 */
29
30 /* $Id: attribute.c 157 2006-04-26 15:07:55Z ktou $ */
31
32 /*LINTLIBRARY*/
33
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <stdarg.h>
37 #include <string.h>
38 #include <ctype.h>
39 #include <alloca.h>
40 #include <papi.h>
41 #include <regex.h>
42
43 #define MAX_PAGES 32767
44 /*
45 * Assuming the maximum number of pages in
46 * a document to be 32767
47 */
48
49 static void papiAttributeFree(papi_attribute_t *attribute);
50
51 static void
52 papiAttributeValueFree(papi_attribute_value_type_t type,
53 papi_attribute_value_t *value)
54 {
55 if (value != NULL) {
56 switch (type) {
57 case PAPI_STRING:
58 if (value->string != NULL)
59 free(value->string);
60 break;
61 case PAPI_COLLECTION:
62 if (value->collection != NULL) {
63 int i;
64
65 for (i = 0; value->collection[i] != NULL; i++)
66 papiAttributeFree(value->collection[i]);
67
68 free(value->collection);
69 }
70 break;
71 default: /* don't need to free anything extra */
72 break;
73 }
74
75 free(value);
76 }
77 }
78
79 static void
80 papiAttributeValuesFree(papi_attribute_value_type_t type,
81 papi_attribute_value_t **values)
82 {
83 if (values != NULL) {
84 int i;
85
86 for (i = 0; values[i] != NULL; i++)
87 papiAttributeValueFree(type, values[i]);
88
89 free(values);
90 }
91 }
92
93 static void
94 papiAttributeFree(papi_attribute_t *attribute)
95 {
96 if (attribute != NULL) {
97 if (attribute->name != NULL)
98 free(attribute->name);
99 if (attribute->values != NULL)
100 papiAttributeValuesFree(attribute->type,
101 attribute->values);
102 free(attribute);
103 }
104 }
105
106 void
107 papiAttributeListFree(papi_attribute_t **list)
108 {
109 if (list != NULL) {
110 int i;
111
112 for (i = 0; list[i] != NULL; i++)
113 papiAttributeFree(list[i]);
114
115 free(list);
116 }
117 }
118
119 static papi_attribute_t **
120 collection_dup(papi_attribute_t **collection)
121 {
122 papi_attribute_t **result = NULL;
123
124 /* allows a NULL collection that is "empty" or "no value" */
125 if (collection != NULL) {
126 papi_status_t status = PAPI_OK;
127 int i;
128
129 for (i = 0; ((collection[i] != NULL) && (status == PAPI_OK));
130 i++) {
131 papi_attribute_t *a = collection[i];
132
133 status = papiAttributeListAddValue(&result,
134 PAPI_ATTR_APPEND, a->name, a->type,
135 NULL);
136 if ((status == PAPI_OK) && (a->values != NULL)) {
137 int j;
138
139 for (j = 0; ((a->values[j] != NULL) &&
140 (status == PAPI_OK)); j++)
141 status = papiAttributeListAddValue(
142 &result,
143 PAPI_ATTR_APPEND,
144 a->name, a->type,
145 a->values[j]);
146 }
147 }
148 if (status != PAPI_OK) {
149 papiAttributeListFree(result);
150 result = NULL;
151 }
152 }
153
154 return (result);
155 }
156
157 static papi_attribute_value_t *
158 papiAttributeValueDup(papi_attribute_value_type_t type,
159 papi_attribute_value_t *v)
160 {
161 papi_attribute_value_t *result = NULL;
162
163 if ((v != NULL) && ((result = calloc(1, sizeof (*result))) != NULL)) {
164 switch (type) {
165 case PAPI_STRING:
166 if (v->string == NULL) {
167 free(result);
168 result = NULL;
169 } else
170 result->string = strdup(v->string);
171 break;
172 case PAPI_INTEGER:
173 result->integer = v->integer;
174 break;
175 case PAPI_BOOLEAN:
176 result->boolean = v->boolean;
177 break;
178 case PAPI_RANGE:
179 result->range.lower = v->range.lower;
180 result->range.upper = v->range.upper;
181 break;
182 case PAPI_RESOLUTION:
183 result->resolution.xres = v->resolution.xres;
184 result->resolution.yres = v->resolution.yres;
185 result->resolution.units = v->resolution.units;
186 break;
187 case PAPI_DATETIME:
188 result->datetime = v->datetime;
189 break;
190 case PAPI_COLLECTION:
191 result->collection = collection_dup(v->collection);
192 break;
193 case PAPI_METADATA:
194 result->metadata = v->metadata;
195 break;
196 default: /* unknown type, fail to duplicate */
197 free(result);
198 result = NULL;
199 }
200 }
201
202 return (result);
203 }
204
205 static papi_attribute_t *
206 papiAttributeAlloc(char *name, papi_attribute_value_type_t type)
207 {
208 papi_attribute_t *result = NULL;
209
210 if ((result = calloc(1, sizeof (*result))) != NULL) {
211 result->name = strdup(name);
212 result->type = type;
213 }
214
215 return (result);
216 }
217
218 static papi_status_t
219 papiAttributeListAppendValue(papi_attribute_value_t ***values,
220 papi_attribute_value_type_t type,
221 papi_attribute_value_t *value)
222 {
223
224 if (values == NULL)
225 return (PAPI_BAD_ARGUMENT);
226
227 if (value != NULL) { /* this allows "empty" attributes */
228 papi_attribute_value_t *tmp = NULL;
229
230 if ((tmp = papiAttributeValueDup(type, value)) == NULL)
231 return (PAPI_TEMPORARY_ERROR);
232
233 list_append(values, tmp);
234 }
235
236 return (PAPI_OK);
237 }
238
239 papi_status_t
240 papiAttributeListAddValue(papi_attribute_t ***list, int flgs,
241 char *name, papi_attribute_value_type_t type,
242 papi_attribute_value_t *value)
243 {
244 papi_status_t result;
245 int flags = flgs;
246 papi_attribute_t *attribute = NULL;
247 papi_attribute_value_t **values = NULL;
248
249 if ((list == NULL) || (name == NULL))
250 return (PAPI_BAD_ARGUMENT);
251
252 if ((type == PAPI_RANGE) && (value != NULL) &&
253 (value->range.lower > value->range.upper))
254 return (PAPI_BAD_ARGUMENT); /* RANGE must have min <= max */
255
256 if (flags == 0) /* if it wasn't set, set a default behaviour */
257 flags = PAPI_ATTR_APPEND;
258
259 /* look for an existing one */
260 attribute = papiAttributeListFind(*list, name);
261
262 if (((flags & PAPI_ATTR_EXCL) != 0) && (attribute != NULL))
263 return (PAPI_CONFLICT); /* EXISTS */
264
265 if (((flags & PAPI_ATTR_REPLACE) == 0) && (attribute != NULL) &&
266 (attribute->type != type))
267 return (PAPI_CONFLICT); /* TYPE CONFLICT */
268
269 /* if we don't have one, create it and add it to the list */
270 if ((attribute == NULL) &&
271 ((attribute = papiAttributeAlloc(name, type)) != NULL))
272 list_append(list, attribute);
273
274 /* if we don't have one by now, it's most likely an alloc fail */
275 if (attribute == NULL)
276 return (PAPI_TEMPORARY_ERROR);
277
278 /*
279 * if we are replacing, clear any existing values, but don't free
280 * until after we have replaced the values, in case we are replacing
281 * a collection with a relocated version of the original collection.
282 */
283 if (((flags & PAPI_ATTR_REPLACE) != 0) && (attribute->values != NULL)) {
284 values = attribute->values;
285 attribute->values = NULL;
286 }
287
288 attribute->type = type;
289
290 result = papiAttributeListAppendValue(&attribute->values, type, value);
291
292 /* free old values if we replaced them */
293 if (values != NULL)
294 papiAttributeValuesFree(type, values);
295
296 return (result);
297 }
298
299 papi_status_t
300 papiAttributeListAddString(papi_attribute_t ***list, int flags,
301 char *name, char *string)
302 {
303 papi_attribute_value_t v;
304
305 v.string = (char *)string;
306 return (papiAttributeListAddValue(list, flags, name, PAPI_STRING, &v));
307 }
308
309 papi_status_t
310 papiAttributeListAddInteger(papi_attribute_t ***list, int flags,
311 char *name, int integer)
312 {
313 papi_attribute_value_t v;
314
315 v.integer = integer;
316 return (papiAttributeListAddValue(list, flags, name, PAPI_INTEGER, &v));
317 }
318
319 papi_status_t
320 papiAttributeListAddBoolean(papi_attribute_t ***list, int flags,
321 char *name, char boolean)
322 {
323 papi_attribute_value_t v;
324
325 v.boolean = boolean;
326 return (papiAttributeListAddValue(list, flags, name, PAPI_BOOLEAN, &v));
327 }
328
329 papi_status_t
330 papiAttributeListAddRange(papi_attribute_t ***list, int flags,
331 char *name, int lower, int upper)
332 {
333 papi_attribute_value_t v;
334
335 v.range.lower = lower;
336 v.range.upper = upper;
337 return (papiAttributeListAddValue(list, flags, name, PAPI_RANGE, &v));
338 }
339
340 papi_status_t
341 papiAttributeListAddResolution(papi_attribute_t ***list, int flags,
342 char *name, int xres, int yres,
343 papi_resolution_unit_t units)
344 {
345 papi_attribute_value_t v;
346
347 v.resolution.xres = xres;
348 v.resolution.yres = yres;
349 v.resolution.units = units;
350 return (papiAttributeListAddValue(list, flags, name,
351 PAPI_RESOLUTION, &v));
352 }
353
354 papi_status_t
355 papiAttributeListAddDatetime(papi_attribute_t ***list, int flags,
356 char *name, time_t datetime)
357 {
358 papi_attribute_value_t v;
359
360 v.datetime = datetime;
361 return (papiAttributeListAddValue(list, flags, name,
362 PAPI_DATETIME, &v));
363 }
364
365 papi_status_t
366 papiAttributeListAddCollection(papi_attribute_t ***list, int flags,
367 char *name, papi_attribute_t **collection)
368 {
369 papi_attribute_value_t v;
370
371 v.collection = (papi_attribute_t **)collection;
372 return (papiAttributeListAddValue(list, flags, name,
373 PAPI_COLLECTION, &v));
374 }
375
376 papi_status_t
377 papiAttributeListAddMetadata(papi_attribute_t ***list, int flags,
378 char *name, papi_metadata_t metadata)
379 {
380 papi_attribute_value_t v;
381
382 v.metadata = metadata;
383 return (papiAttributeListAddValue(list, flags, name,
384 PAPI_METADATA, &v));
385 }
386
387 papi_status_t
388 papiAttributeListDelete(papi_attribute_t ***list, char *name)
389 {
390 papi_attribute_t *attribute;
391
392 if ((list == NULL) || (name == NULL))
393 return (PAPI_BAD_ARGUMENT);
394
395 if ((attribute = papiAttributeListFind(*list, name)) == NULL)
396 return (PAPI_NOT_FOUND);
397
398 list_remove(list, attribute);
399 papiAttributeFree(attribute);
400
401 return (PAPI_OK);
402 }
403
404 papi_attribute_t *
405 papiAttributeListFind(papi_attribute_t **list, char *name)
406 {
407 int i;
408 if ((list == NULL) || (name == NULL))
409 return (NULL);
410
411 for (i = 0; list[i] != NULL; i++)
412 if (strcasecmp(list[i]->name, name) == 0)
413 return ((papi_attribute_t *)list[i]);
414
415 return (NULL);
416 }
417
418 papi_attribute_t *
419 papiAttributeListGetNext(papi_attribute_t **list, void **iter)
420 {
421 papi_attribute_t **tmp, *result;
422
423 if ((list == NULL) && (iter == NULL))
424 return (NULL);
425
426 if (*iter == NULL)
427 *iter = list;
428
429 tmp = *iter;
430 result = *tmp;
431 *iter = ++tmp;
432
433 return (result);
434 }
435
436 papi_status_t
437 papiAttributeListGetValue(papi_attribute_t **list, void **iter,
438 char *name, papi_attribute_value_type_t type,
439 papi_attribute_value_t **value)
440 {
441 papi_attribute_value_t **tmp;
442 void *fodder = NULL;
443
444 if ((list == NULL) || ((name == NULL) && (iter == NULL)) ||
445 (value == NULL))
446 return (PAPI_BAD_ARGUMENT);
447
448 if (iter == NULL)
449 iter = &fodder;
450
451 if ((iter == NULL) || (*iter == NULL)) {
452 papi_attribute_t *attr = papiAttributeListFind(list, name);
453
454 if (attr == NULL)
455 return (PAPI_NOT_FOUND);
456
457 if (attr->type != type)
458 return (PAPI_NOT_POSSIBLE);
459
460 tmp = attr->values;
461 } else
462 tmp = *iter;
463
464 if (tmp == NULL)
465 return (PAPI_NOT_FOUND);
466
467 *value = *tmp;
468 *iter = ++tmp;
469
470 if (*value == NULL)
471 return (PAPI_GONE);
472
473 return (PAPI_OK);
474 }
475
476 papi_status_t
477 papiAttributeListGetString(papi_attribute_t **list, void **iter,
478 char *name, char **vptr)
479 {
480 papi_status_t status;
481 papi_attribute_value_t *value = NULL;
482
483 if (vptr == NULL)
484 return (PAPI_BAD_ARGUMENT);
485
486 status = papiAttributeListGetValue(list, iter, name,
487 PAPI_STRING, &value);
488 if (status == PAPI_OK)
489 *vptr = value->string;
490
491 return (status);
492 }
493
494 papi_status_t
495 papiAttributeListGetInteger(papi_attribute_t **list, void **iter,
496 char *name, int *vptr)
497 {
498 papi_status_t status;
499 papi_attribute_value_t *value = NULL;
500
501 if (vptr == NULL)
502 return (PAPI_BAD_ARGUMENT);
503
504 status = papiAttributeListGetValue(list, iter, name,
505 PAPI_INTEGER, &value);
506 if (status == PAPI_OK)
507 *vptr = value->integer;
508
509 return (status);
510 }
511
512 papi_status_t
513 papiAttributeListGetBoolean(papi_attribute_t **list, void **iter,
514 char *name, char *vptr)
515 {
516 papi_status_t status;
517 papi_attribute_value_t *value = NULL;
518
519 if (vptr == NULL)
520 return (PAPI_BAD_ARGUMENT);
521
522 status = papiAttributeListGetValue(list, iter, name,
523 PAPI_BOOLEAN, &value);
524 if (status == PAPI_OK)
525 *vptr = value->boolean;
526
527 return (status);
528 }
529
530 papi_status_t
531 papiAttributeListGetRange(papi_attribute_t **list, void **iter,
532 char *name, int *min, int *max)
533 {
534 papi_status_t status;
535 papi_attribute_value_t *value = NULL;
536
537 if ((min == NULL) || (max == NULL))
538 return (PAPI_BAD_ARGUMENT);
539
540 status = papiAttributeListGetValue(list, iter, name,
541 PAPI_RANGE, &value);
542 if (status == PAPI_OK) {
543 *min = value->range.lower;
544 *max = value->range.upper;
545 }
546
547 return (status);
548 }
549
550 papi_status_t
551 papiAttributeListGetResolution(papi_attribute_t **list, void **iter,
552 char *name, int *x, int *y,
553 papi_resolution_unit_t *units)
554 {
555 papi_status_t status;
556 papi_attribute_value_t *value = NULL;
557
558 if ((x == NULL) || (y == NULL) || (units == NULL))
559 return (PAPI_BAD_ARGUMENT);
560
561 status = papiAttributeListGetValue(list, iter, name,
562 PAPI_RESOLUTION, &value);
563 if (status == PAPI_OK) {
564 *x = value->resolution.xres;
565 *y = value->resolution.yres;
566 *units = value->resolution.units;
567 }
568
569 return (status);
570 }
571
572 papi_status_t
573 papiAttributeListGetDatetime(papi_attribute_t **list, void **iter,
574 char *name, time_t *dt)
575 {
576 papi_status_t status;
577 papi_attribute_value_t *value = NULL;
578
579 if (dt == NULL)
580 return (PAPI_BAD_ARGUMENT);
581
582 status = papiAttributeListGetValue(list, iter, name,
583 PAPI_DATETIME, &value);
584 if (status == PAPI_OK) {
585 *dt = value->datetime;
586 }
587
588 return (status);
589 }
590
591 papi_status_t
592 papiAttributeListGetCollection(papi_attribute_t **list, void **iter,
593 char *name, papi_attribute_t ***collection)
594 {
595 papi_status_t status;
596 papi_attribute_value_t *value = NULL;
597
598 if (collection == NULL)
599 return (PAPI_BAD_ARGUMENT);
600
601 status = papiAttributeListGetValue(list, iter, name,
602 PAPI_COLLECTION, &value);
603 if (status == PAPI_OK) {
604 *collection = value->collection;
605 }
606
607 return (status);
608 }
609
610 papi_status_t
611 papiAttributeListGetMetadata(papi_attribute_t **list, void **iter,
612 char *name, papi_metadata_t *vptr)
613 {
614 papi_status_t status;
615 papi_attribute_value_t *value = NULL;
616
617 if (vptr == NULL)
618 return (PAPI_BAD_ARGUMENT);
619
620 status = papiAttributeListGetValue(list, iter, name,
621 PAPI_METADATA, &value);
622 if (status == PAPI_OK)
623 *vptr = value->metadata;
624
625 return (status);
626 }
627
628
629 /* The string is modified by this call */
630 static char *
631 regvalue(regmatch_t match, char *string)
632 {
633 char *result = NULL;
634 if (match.rm_so != match.rm_eo) {
635 result = string + match.rm_so;
636 *(result + (match.rm_eo - match.rm_so)) = '\0';
637 }
638 return (result);
639 }
640
641 static papi_attribute_value_type_t
642 _process_value(char *string, char ***parts)
643 {
644 int i;
645 static struct {
646 papi_attribute_value_type_t type;
647 size_t vals;
648 char *expression;
649 int compiled;
650 regex_t re;
651 } types[] = {
652 { PAPI_BOOLEAN, 1, "^(true|false|yes|no)$", 0 },
653 { PAPI_COLLECTION, 1, "^\\{(.+)\\}$", 0 },
654 /* PAPI_DATETIME is unsupported, too much like an integer */
655 { PAPI_INTEGER, 1, "^([+-]{0,1}[[:digit:]]+)$", 0 },
656 { PAPI_RANGE, 3, "^([[:digit:]]*)-([[:digit:]]*)$", 0 },
657 { PAPI_RESOLUTION, 4, "^([[:digit:]]+)x([[:digit:]]+)dp(i|c)$",
658 0 },
659 NULL
660 };
661 regmatch_t matches[4];
662
663 for (i = 0; i < 5; i++) {
664 int j;
665
666 if (types[i].compiled == 0) {
667 (void) regcomp(&(types[i].re), types[i].expression,
668 REG_EXTENDED|REG_ICASE);
669 types[i].compiled = 1;
670 }
671 if (regexec(&(types[i].re), string, (size_t)types[i].vals,
672 matches, 0) == REG_NOMATCH)
673 continue;
674
675 for (j = 0 ; j < types[i].vals; j++)
676 list_append(parts, regvalue(matches[j], string));
677 return (types[i].type);
678 }
679
680 list_append(parts, string);
681 return (PAPI_STRING);
682 }
683
684 static void
685 _add_attribute_value(papi_attribute_value_t ***list,
686 papi_attribute_value_type_t type,
687 papi_attribute_value_type_t dtype, char **parts)
688 {
689 papi_attribute_value_t *value = calloc(1, sizeof (*value));
690
691 switch(type) {
692 case PAPI_STRING:
693 value->string = strdup(parts[0]);
694 list_append(list, value);
695 break;
696 case PAPI_BOOLEAN:
697 value->boolean = PAPI_TRUE;
698 if ((strcasecmp(parts[0], "false") == 0) ||
699 (strcasecmp(parts[0], "no") == 0))
700 value->boolean = PAPI_FALSE;
701 list_append(list, value);
702 break;
703 case PAPI_INTEGER:
704 value->integer = atoi(parts[0]);
705 list_append(list, value);
706 break;
707 case PAPI_RANGE:
708 if (dtype == PAPI_INTEGER) {
709 if (atoi(parts[0]) < 0) {
710 /*
711 * Handles -P -x case
712 * which prints from page number 1
713 * till page number x
714 */
715 value->range.lower = 1;
716 value->range.upper = 0 - (atoi(parts[0]));
717 } else {
718 value->range.lower = value->range.upper
719 = atoi(parts[0]);
720 }
721 } else if (dtype == PAPI_RANGE) {
722 if (parts[2] == NULL) {
723 value->range.lower = atoi(parts[1]);
724 /*
725 * Imposing an artificial limit on
726 * the upper bound for page range.
727 */
728 value->range.upper = MAX_PAGES;
729 } else if ((parts[1] != NULL) && (parts[2] != NULL)) {
730 value->range.lower = atoi(parts[1]);
731 value->range.upper = atoi(parts[2]);
732 }
733 }
734 list_append(list, value);
735 break;
736 case PAPI_RESOLUTION:
737 value->resolution.xres = atoi(parts[1]);
738 value->resolution.yres = atoi(parts[2]);
739 if (parts[3][0] == 'i')
740 value->resolution.units = PAPI_RES_PER_INCH;
741 else
742 value->resolution.units = PAPI_RES_PER_CM;
743 list_append(list, value);
744 break;
745 case PAPI_COLLECTION:
746 papiAttributeListFromString(&(value->collection), 0, parts[0]);
747 list_append(list, value);
748 break;
749 }
750 }
751
752 static papi_status_t
753 _papiAttributeFromStrings(papi_attribute_t ***list, int flags,
754 char *key, char **values)
755 {
756 int i;
757 papi_status_t result = PAPI_OK;
758 papi_attribute_t *attr = calloc(1, sizeof (*attr));
759
760 /* these are specified in the papi spec as ranges */
761 char *ranges[] = { "copies-supported", "job-impressions-supported",
762 "job-k-octets-supported",
763 "job-media-sheets-supported", "page-ranges",
764 NULL };
765
766 if ((attr == NULL) || ((attr->name = strdup(key)) == NULL))
767 return (PAPI_TEMPORARY_ERROR);
768
769 attr->type = PAPI_METADATA;
770 /* these are known ranges */
771 for (i = 0; ranges[i] != NULL; i++)
772 if (strcasecmp(attr->name, ranges[i]) == 0) {
773 attr->type = PAPI_RANGE;
774 break;
775 }
776
777 if (values != NULL) {
778 papi_attribute_value_t **vals = NULL;
779
780 for (i = 0; values[i] != NULL; i++) {
781 papi_attribute_value_type_t dtype;
782 char **parts = NULL;
783
784 dtype = _process_value(values[i], &parts);
785 if (attr->type == PAPI_METADATA)
786 attr->type = dtype;
787 _add_attribute_value(&vals, attr->type, dtype, parts);
788 free(parts);
789 }
790 attr->values = vals;
791 }
792
793 list_append(list, attr);
794
795 return (result);
796 }
797
798 static papi_status_t
799 _parse_attribute_list(papi_attribute_t ***list, int flags, char *string)
800 {
801 papi_status_t result = PAPI_OK;
802 char *ptr;
803
804 if ((list == NULL) || (string == NULL))
805 return (PAPI_BAD_ARGUMENT);
806
807 if ((ptr = strdup(string)) == NULL)
808 return (PAPI_TEMPORARY_ERROR);
809
810 while ((*ptr != '\0') && (result == PAPI_OK)) {
811 char *key, **values = NULL;
812
813 /* strip any leading whitespace */
814 while (isspace(*ptr) != 0)
815 ptr++;
816
817 /* Get the name: name[=value] */
818 key = ptr;
819 while ((*ptr != '\0') && (*ptr != '=') && (isspace(*ptr) == 0))
820 ptr++;
821
822 if (*ptr == '=') {
823 *ptr++ = '\0';
824
825 while ((*ptr != '\0') && (isspace(*ptr) == 0)) {
826 char *value = ptr;
827
828 if ((*ptr == '\'') || (*ptr == '"')) {
829 char q = *ptr++;
830
831 /* quoted string value */
832 while ((*ptr != '\0') && (*ptr != q))
833 ptr++;
834 if (*ptr == q)
835 ptr++;
836 } else if (*ptr == '{') {
837 /* collection */
838 while ((*ptr != '\0') && (*ptr != '}'))
839 ptr++;
840 if (*ptr == '}')
841 ptr++;
842 } else {
843 /* value */
844 while ((*ptr != '\0') &&
845 (*ptr != ',') &&
846 (isspace(*ptr) == 0))
847 ptr++;
848 }
849 if (*ptr == ',')
850 *ptr++ = '\0';
851 list_append(&values, value);
852 }
853 } else { /* boolean "[no]key" */
854 char *value = "true";
855
856 if (strncasecmp(key, "no", 2) == 0) {
857 key += 2;
858 value = "false";
859 }
860 list_append(&values, value);
861 }
862 if (*ptr != '\0')
863 *ptr++ = '\0';
864
865 result = _papiAttributeFromStrings(list, flags, key, values);
866 free(values);
867 }
868
869 return (result);
870 }
871
872 papi_status_t
873 papiAttributeListFromString(papi_attribute_t ***attrs,
874 int flags, char *string)
875 {
876 papi_status_t result = PAPI_OK;
877
878 if ((attrs != NULL) && (string != NULL) &&
879 ((flags & ~(PAPI_ATTR_APPEND+PAPI_ATTR_REPLACE+PAPI_ATTR_EXCL))
880 == 0)) {
881 result = _parse_attribute_list(attrs, flags, string);
882 } else {
883 result = PAPI_BAD_ARGUMENT;
884 }
885
886 return (result);
887 }
888
889 static papi_status_t
890 papiAttributeToString(papi_attribute_t *attribute, char *delim,
891 char *buffer, size_t buflen)
892 {
893 papi_attribute_value_t **values = attribute->values;
894 int rc, i;
895
896 if ((attribute->type == PAPI_BOOLEAN) && (values[1] == NULL)) {
897 if (values[0]->boolean == PAPI_FALSE) {
898 if (isupper(attribute->name[0]) == 0)
899 strlcat(buffer, "no", buflen);
900 else
901 strlcat(buffer, "No", buflen);
902 }
903 rc = strlcat(buffer, attribute->name, buflen);
904 } else {
905 strlcat(buffer, attribute->name, buflen);
906 rc = strlcat(buffer, "=", buflen);
907 }
908
909 if (values == NULL)
910 return (PAPI_OK);
911
912 for (i = 0; values[i] != NULL; i++) {
913 switch (attribute->type) {
914 case PAPI_STRING:
915 rc = strlcat(buffer, values[i]->string, buflen);
916 break;
917 case PAPI_INTEGER: {
918 char string[24];
919
920 snprintf(string, sizeof (string), "%d",
921 values[i]->integer);
922 rc = strlcat(buffer, string, buflen);
923 }
924 break;
925 case PAPI_BOOLEAN:
926 if (values[1] != NULL)
927 rc = strlcat(buffer, (values[i]->boolean ?
928 "true" : "false"), buflen);
929 break;
930 case PAPI_RANGE: {
931 char string[24];
932
933 if (values[i]->range.lower == values[i]->range.upper)
934 snprintf(string, sizeof (string), "%d",
935 values[i]->range.lower);
936 else
937 snprintf(string, sizeof (string), "%d-%d",
938 values[i]->range.lower,
939 values[i]->range.upper);
940 rc = strlcat(buffer, string, buflen);
941 }
942 break;
943 case PAPI_RESOLUTION: {
944 char string[24];
945
946 snprintf(string, sizeof (string), "%dx%ddp%c",
947 values[i]->resolution.xres,
948 values[i]->resolution.yres,
949 (values[i]->resolution.units == PAPI_RES_PER_CM
950 ? 'c' : 'i'));
951 rc = strlcat(buffer, string, buflen);
952 }
953 break;
954 case PAPI_DATETIME: {
955 struct tm *tm = localtime(&values[i]->datetime);
956
957 if (tm != NULL) {
958 char string[64];
959
960 strftime(string, sizeof (string), "%c", tm);
961 rc = strlcat(buffer, string, buflen);
962 }}
963 break;
964 case PAPI_COLLECTION: {
965 char *string = alloca(buflen);
966
967 papiAttributeListToString(values[i]->collection,
968 delim, string, buflen);
969 rc = strlcat(buffer, string, buflen);
970 }
971 break;
972 default: {
973 char string[32];
974
975 snprintf(string, sizeof (string), "unknown-type-0x%x",
976 attribute->type);
977 rc = strlcat(buffer, string, buflen);
978 }
979 }
980 if (values[i+1] != NULL)
981 rc = strlcat(buffer, ",", buflen);
982
983 if (rc >= buflen)
984 return (PAPI_NOT_POSSIBLE);
985
986 }
987
988 return (PAPI_OK);
989 }
990
991 papi_status_t
992 papiAttributeListToString(papi_attribute_t **attrs,
993 char *delim, char *buffer, size_t buflen)
994 {
995 papi_status_t status = PAPI_OK;
996 int i;
997
998 if ((attrs == NULL) || (buffer == NULL))
999 return (PAPI_BAD_ARGUMENT);
1000
1001 buffer[0] = '\0';
1002 if (!delim)
1003 delim = " ";
1004
1005 for (i = 0; ((attrs[i] != NULL) && (status == PAPI_OK)); i++) {
1006 status = papiAttributeToString(attrs[i], delim, buffer, buflen);
1007 if (attrs[i+1] != NULL)
1008 strlcat(buffer, delim, buflen);
1009 }
1010
1011 return (status);
1012 }
1013
1014 static int
1015 is_in_list(char *value, char **list)
1016 {
1017 if ((list != NULL) && (value != NULL)) {
1018 int i;
1019
1020 for (i = 0; list[i] != NULL; i++)
1021 if (strcasecmp(value, list[i]) == 0)
1022 return (0);
1023 }
1024
1025 return (1);
1026 }
1027
1028 static papi_status_t
1029 copy_attribute(papi_attribute_t ***list, papi_attribute_t *attribute)
1030 {
1031 papi_status_t status;
1032 int i = 0;
1033
1034 if ((list == NULL) || (attribute == NULL) ||
1035 (attribute->values == NULL))
1036 return (PAPI_BAD_ARGUMENT);
1037
1038 for (status = papiAttributeListAddValue(list, PAPI_ATTR_EXCL,
1039 attribute->name, attribute->type,
1040 attribute->values[i]);
1041 ((status == PAPI_OK) && (attribute->values[i] != NULL));
1042 status = papiAttributeListAddValue(list, PAPI_ATTR_APPEND,
1043 attribute->name, attribute->type,
1044 attribute->values[i]))
1045 i++;
1046
1047 return (status);
1048 }
1049
1050 void
1051 copy_attributes(papi_attribute_t ***result, papi_attribute_t **attributes)
1052 {
1053 int i;
1054
1055 if ((result == NULL) || (attributes == NULL))
1056 return;
1057
1058 for (i = 0; attributes[i] != NULL; i++)
1059 copy_attribute(result, attributes[i]);
1060 }
1061
1062 void
1063 split_and_copy_attributes(char **list, papi_attribute_t **attributes,
1064 papi_attribute_t ***in, papi_attribute_t ***out)
1065 {
1066 int i;
1067
1068 if ((list == NULL) || (attributes == NULL))
1069 return;
1070
1071 for (i = 0; attributes[i] != NULL; i++)
1072 if (is_in_list(attributes[i]->name, list) == 0)
1073 copy_attribute(in, attributes[i]);
1074 else
1075 copy_attribute(out, attributes[i]);
1076 }
1077
1078 void
1079 papiAttributeListPrint(FILE *fp, papi_attribute_t **attributes,
1080 char *prefix_fmt, ...)
1081 {
1082 char *prefix = NULL;
1083 char *buffer = NULL;
1084 char *newfmt = NULL;
1085 void *mem;
1086 ssize_t size = 0;
1087 va_list ap;
1088
1089 newfmt = malloc(strlen(prefix_fmt) + 2);
1090 sprintf(newfmt, "\n%s", prefix_fmt);
1091
1092 va_start(ap, prefix_fmt);
1093 while (vsnprintf(prefix, size, newfmt, ap) > size) {
1094 size += 1024;
1095 mem = realloc(prefix, size);
1096 if (!mem) goto error;
1097 prefix = mem;
1098 }
1099 va_end(ap);
1100
1101 if (attributes) {
1102 size = 0;
1103 while (papiAttributeListToString(attributes, prefix, buffer,
1104 size) != PAPI_OK) {
1105 size += 1024;
1106 mem = realloc(buffer, size);
1107 if (!mem) goto error;
1108 buffer = mem;
1109 }
1110 }
1111
1112 fprintf(fp, "%s%s\n", prefix, buffer ? buffer : "");
1113 fflush(fp);
1114
1115 error:
1116 free(newfmt);
1117 free(prefix);
1118 free(buffer);
1119 }