Debian Codegraph @

src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/adapters/string_utils.c

raw
1 // Copyright (C) Microsoft Corporation. All rights reserved.
2
3 /*poor man's string routines*/
4 #include <stdio.h>
5 #include <stdlib.h>
6 #include <wchar.h>
7
8 #include "windows.h"
9
10 #include "azure_macro_utils/macro_utils.h"
11 #include "azure_c_shared_utility/gballoc.h"
12 #include "azure_c_shared_utility/xlogging.h"
13 #include "azure_c_shared_utility/safe_math.h"
14
15 #include "azure_c_shared_utility/string_utils.h"
16
17 IMPLEMENT_MOCKABLE_FUNCTION(, char*, vsprintf_char, const char*, format, va_list, va)
18 {
19 char* result;
20 int neededSize = vsnprintf(NULL, 0, format, va);
21 if (neededSize < 0)
22 {
23 LogError("failure in vsnprintf, neededSize=%d", neededSize);
24 result = NULL;
25 }
26 else
27 {
28 size_t len = safe_add_size_t((unsigned long long)neededSize, 1);
29 size_t malloc_size = safe_multiply_size_t(len, sizeof(char));
30 if (malloc_size == SIZE_MAX)
31 {
32 LogError("invalid malloc size, size:%zu", malloc_size);
33 result = NULL;
34 /*return as is*/
35 }
36 else if ((result = (char*)malloc(malloc_size)) == NULL)
37 {
38 LogError("failure in malloc");
39 /*return as is*/
40 }
41 else
42 {
43 int out_len = vsnprintf(result, len, format, va);
44 if (out_len != neededSize)
45 {
46 LogError("inconsistent vsnprintf behavior, len=%zu, out_len=%d", len, out_len);
47 free(result);
48 result = NULL;
49 }
50 }
51 }
52 return result;
53 }
54
55 IMPLEMENT_MOCKABLE_FUNCTION(, wchar_t*, vsprintf_wchar, const wchar_t*, format, va_list, va)
56 {
57 wchar_t* result;
58 int neededSize = vswprintf(NULL, 0, format, va);
59 if (neededSize < 0)
60 {
61 LogError("failure in swprintf");
62 result = NULL;
63 }
64 else
65 {
66 size_t malloc_size = safe_add_size_t((unsigned long long)neededSize, 1);
67 malloc_size = safe_multiply_size_t(malloc_size, sizeof(wchar_t));
68 if (malloc_size == SIZE_MAX)
69 {
70 LogError("invalid malloc size");
71 result = NULL;
72 /*return as is*/
73 }
74 else if ((result = (wchar_t*)malloc(malloc_size)) == NULL)
75 {
76 LogError("failure in malloc");
77 /*return as is*/
78 }
79 else
80 {
81 if (vswprintf(result, (unsigned long long)neededSize + 1, format, va) != neededSize)
82 {
83 LogError("inconsistent vswprintf behavior");
84 free(result);
85 result = NULL;
86 }
87 }
88 }
89 return result;
90 }
91
92 /*returns a char* that is as if printed by printf*/
93 /*needs to be free'd after usage*/
94 char* sprintf_char_function(const char* format, ...)
95 {
96 char* result;
97 va_list va;
98 va_start(va, format);
99 result = vsprintf_char(format, va);
100 va_end(va);
101 return result;
102 }
103
104 wchar_t* sprintf_wchar_function(const wchar_t* format, ...)
105 {
106 wchar_t* result;
107 va_list va;
108 va_start(va, format);
109 result = vsprintf_wchar(format, va);
110 va_end(va);
111 return result;
112 }
113
114 /*takes a FILETIME, returns a nice string representation of it*/
115 char* FILETIME_toAsciiArray(const FILETIME* fileTime)
116 {
117 char* result;
118 if (fileTime == NULL)
119 {
120 LogError("invalid argument const FILETIME* fileTime=%p", fileTime);
121 result = NULL;
122 }
123 else
124 {
125 FILETIME localFileTime;
126 if (FileTimeToLocalFileTime(fileTime, &localFileTime) == 0)
127 {
128 LogLastError("failure in FileTimeToLocalFileTime");
129 result = NULL;
130 }
131 else
132 {
133 SYSTEMTIME systemTime;
134 if (FileTimeToSystemTime(&localFileTime, &systemTime) == 0)
135 {
136 LogLastError("failure in FileTimeToLocalFileTime");
137 result = NULL;
138 }
139 else
140 {
141 char localDate[255];
142 if (GetDateFormat(LOCALE_USER_DEFAULT, DATE_LONGDATE, &systemTime, NULL, localDate, sizeof(localDate)/sizeof(localDate[0])) == 0)
143 {
144 LogLastError("failure in GetDateFormat");
145 result = NULL;
146 }
147 else
148 {
149 char localTime[255];
150 if (GetTimeFormat(LOCALE_USER_DEFAULT, 0, &systemTime, NULL, localTime, sizeof(localTime)/sizeof(localTime[0])) == 0)
151 {
152 LogLastError("failure in GetTimeFormat");
153 result = NULL;
154 }
155 else
156 {
157 result = sprintf_char("%s %s", localDate, localTime);
158 /*return as is*/
159 }
160 }
161 }
162 }
163 }
164 return result;
165 }
166
167 IMPLEMENT_MOCKABLE_FUNCTION(, wchar_t*, mbs_to_wcs, const char*, source)
168 {
169 wchar_t *result;
170 if (source == NULL)
171 {
172 LogError("invalid argument const char* source=%s", MU_P_OR_NULL(source));
173 result = NULL;
174 }
175 else
176 {
177 const char* sameAsSource = source;
178 /*assuming source is a multibyte character string*/
179 mbstate_t state = { 0 };/*initial state!*/
180 size_t nwc = mbsrtowcs(NULL, &sameAsSource, 0, &state); /*note 350 from C standard seems to indicate that NULL is a valid pointer to pass here*/
181 if (nwc == (size_t)(-1))
182 {
183 LogError("failure to get the length of the string %s in multibyte characters", strerror(errno));
184 result = NULL;
185 }
186 else
187 {
188 size_t malloc_size = safe_add_size_t(nwc, 1);
189 malloc_size = safe_multiply_size_t(malloc_size, sizeof(wchar_t));
190 if (malloc_size == SIZE_MAX)
191 {
192 LogError("invalid malloc size");
193 result = NULL;
194 /*return as is*/
195 }
196 else if ((result = (wchar_t*)malloc(malloc_size)) == NULL)
197 {
198 LogError("failure in malloc");
199 /*return as is*/
200 }
201 else
202 {
203 size_t nwc2 = mbsrtowcs(result, &sameAsSource, nwc+1, &state);
204 if (nwc2 != nwc)
205 {
206 LogError("unexpected inconsistency in mbsrtowcs");
207 }
208 else
209 {
210 /*all is fine*/
211 goto allOk;
212 }
213 free(result);
214 result = NULL;
215 }
216 allOk:;
217 }
218 }
219 return result;
220 }
221
222 IMPLEMENT_MOCKABLE_FUNCTION(, char*, wcs_to_mbs, const wchar_t*, source)
223 {
224 char *result;
225 if (source == NULL)
226 {
227 LogError("invalid argument const wchar_t* source=%ls", MU_WP_OR_NULL(source));
228 result = NULL;
229 }
230 else
231 {
232 const wchar_t* sameAsSource = source;
233 mbstate_t state = { 0 };/*initial state!*/
234 size_t nc = wcsrtombs(NULL, &sameAsSource, 0, &state);
235 if (nc == (size_t)(-1))
236 {
237 LogError("failure to get the length of the string %s in characters", strerror(errno));
238 result = NULL;
239 }
240 else
241 {
242 size_t malloc_size = safe_add_size_t(nc, 1);
243 malloc_size = safe_multiply_size_t(malloc_size, sizeof(char));
244 if (malloc_size == SIZE_MAX)
245 {
246 LogError("invalid malloc size");
247 result = NULL;
248 /*return as is*/
249 }
250 else if ((result = (char*)malloc(malloc_size)) == NULL)
251 {
252 LogError("failure in malloc");
253 /*return as is*/
254 }
255 else
256 {
257 size_t nc2 = wcsrtombs(result, &sameAsSource, nc + 1, &state);
258 if (nc2 != nc)
259 {
260 LogError("unexpected inconsistency in wcsrtombs");
261 }
262 else
263 {
264 /*all is fine*/
265 goto allOk;
266 }
267 free(result);
268 result = NULL;
269 }
270 allOk:;
271 }
272 }
273 return result;
274 }