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 * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
23 */
24
25 #include "libuutil_common.h"
26
27 #include <stdarg.h>
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <string.h>
31
32 void *
uu_zalloc(size_t n)33 uu_zalloc(size_t n)
34 {
35 void *p = malloc(n);
36
37 if (p == NULL) {
38 uu_set_error(UU_ERROR_SYSTEM);
39 return (NULL);
40 }
41
42 (void) memset(p, 0, n);
43
44 return (p);
45 }
46
47 void
uu_free(void * p)48 uu_free(void *p)
49 {
50 free(p);
51 }
52
53 char *
uu_strdup(const char * str)54 uu_strdup(const char *str)
55 {
56 char *buf = NULL;
57
58 if (str != NULL) {
59 size_t sz;
60
61 sz = strlen(str) + 1;
62 buf = uu_zalloc(sz);
63 if (buf != NULL)
64 (void) memcpy(buf, str, sz);
65 }
66 return (buf);
67 }
68
69 /*
70 * Duplicate up to n bytes of a string. Kind of sort of like
71 * strdup(strlcpy(s, n)).
72 */
73 char *
uu_strndup(const char * s,size_t n)74 uu_strndup(const char *s, size_t n)
75 {
76 size_t len;
77 char *p;
78
79 len = strnlen(s, n);
80 p = uu_zalloc(len + 1);
81 if (p == NULL)
82 return (NULL);
83
84 if (len > 0)
85 (void) memcpy(p, s, len);
86 p[len] = '\0';
87
88 return (p);
89 }
90
91 /*
92 * Duplicate a block of memory. Combines malloc with memcpy, much as
93 * strdup combines malloc, strlen, and strcpy.
94 */
95 void *
uu_memdup(const void * buf,size_t sz)96 uu_memdup(const void *buf, size_t sz)
97 {
98 void *p;
99
100 p = uu_zalloc(sz);
101 if (p == NULL)
102 return (NULL);
103 (void) memcpy(p, buf, sz);
104 return (p);
105 }
106
107 char *
uu_msprintf(const char * format,...)108 uu_msprintf(const char *format, ...)
109 {
110 va_list args;
111 char attic[1];
112 uint_t M, m;
113 char *b;
114
115 va_start(args, format);
116 M = vsnprintf(attic, 1, format, args);
117 va_end(args);
118
119 for (;;) {
120 m = M;
121 if ((b = uu_zalloc(m + 1)) == NULL)
122 return (NULL);
123
124 va_start(args, format);
125 M = vsnprintf(b, m + 1, format, args);
126 va_end(args);
127
128 if (M == m)
129 break; /* sizes match */
130
131 uu_free(b);
132 }
133
134 return (b);
135 }
136