diff options
Diffstat (limited to 'src/util/strings.c')
-rw-r--r-- | src/util/strings.c | 264 |
1 files changed, 133 insertions, 131 deletions
diff --git a/src/util/strings.c b/src/util/strings.c index fa445f694..a95981690 100644 --- a/src/util/strings.c +++ b/src/util/strings.c | |||
@@ -55,8 +55,7 @@ | |||
55 | * (or number of bytes that would have been written) | 55 | * (or number of bytes that would have been written) |
56 | */ | 56 | */ |
57 | size_t | 57 | size_t |
58 | GNUNET_STRINGS_buffer_fill (char *buffer, | 58 | GNUNET_STRINGS_buffer_fill (char *buffer, size_t size, unsigned int count, ...) |
59 | size_t size, unsigned int count, ...) | ||
60 | { | 59 | { |
61 | size_t needed; | 60 | size_t needed; |
62 | size_t slen; | 61 | size_t slen; |
@@ -66,17 +65,18 @@ GNUNET_STRINGS_buffer_fill (char *buffer, | |||
66 | needed = 0; | 65 | needed = 0; |
67 | va_start (ap, count); | 66 | va_start (ap, count); |
68 | while (count > 0) | 67 | while (count > 0) |
68 | { | ||
69 | s = va_arg (ap, const char *); | ||
70 | |||
71 | slen = strlen (s) + 1; | ||
72 | if (buffer != NULL) | ||
69 | { | 73 | { |
70 | s = va_arg (ap, const char *); | 74 | GNUNET_assert (needed + slen <= size); |
71 | slen = strlen (s) + 1; | 75 | memcpy (&buffer[needed], s, slen); |
72 | if (buffer != NULL) | ||
73 | { | ||
74 | GNUNET_assert (needed + slen <= size); | ||
75 | memcpy (&buffer[needed], s, slen); | ||
76 | } | ||
77 | needed += slen; | ||
78 | count--; | ||
79 | } | 76 | } |
77 | needed += slen; | ||
78 | count--; | ||
79 | } | ||
80 | va_end (ap); | 80 | va_end (ap); |
81 | return needed; | 81 | return needed; |
82 | } | 82 | } |
@@ -107,20 +107,21 @@ GNUNET_STRINGS_buffer_tokenize (const char *buffer, | |||
107 | needed = 0; | 107 | needed = 0; |
108 | va_start (ap, count); | 108 | va_start (ap, count); |
109 | while (count > 0) | 109 | while (count > 0) |
110 | { | ||
111 | r = va_arg (ap, const char **); | ||
112 | |||
113 | start = needed; | ||
114 | while ((needed < size) && (buffer[needed] != '\0')) | ||
115 | needed++; | ||
116 | if (needed == size) | ||
110 | { | 117 | { |
111 | r = va_arg (ap, const char **); | 118 | va_end (ap); |
112 | start = needed; | 119 | return 0; /* error */ |
113 | while ((needed < size) && (buffer[needed] != '\0')) | ||
114 | needed++; | ||
115 | if (needed == size) | ||
116 | { | ||
117 | va_end (ap); | ||
118 | return 0; /* error */ | ||
119 | } | ||
120 | *r = &buffer[start]; | ||
121 | needed++; /* skip 0-termination */ | ||
122 | count--; | ||
123 | } | 120 | } |
121 | *r = &buffer[start]; | ||
122 | needed++; /* skip 0-termination */ | ||
123 | count--; | ||
124 | } | ||
124 | va_end (ap); | 125 | va_end (ap); |
125 | return needed; | 126 | return needed; |
126 | } | 127 | } |
@@ -139,25 +140,25 @@ GNUNET_STRINGS_byte_size_fancy (unsigned long long size) | |||
139 | char *ret; | 140 | char *ret; |
140 | 141 | ||
141 | if (size > 5 * 1024) | 142 | if (size > 5 * 1024) |
143 | { | ||
144 | size = size / 1024; | ||
145 | unit = _( /* size unit */ "KiB"); | ||
146 | if (size > 5 * 1024) | ||
142 | { | 147 | { |
143 | size = size / 1024; | 148 | size = size / 1024; |
144 | unit = _( /* size unit */ "KiB"); | 149 | unit = _( /* size unit */ "MiB"); |
145 | if (size > 5 * 1024) | 150 | if (size > 5 * 1024) |
151 | { | ||
152 | size = size / 1024; | ||
153 | unit = _( /* size unit */ "GiB"); | ||
154 | if (size > 5 * 1024) | ||
146 | { | 155 | { |
147 | size = size / 1024; | 156 | size = size / 1024; |
148 | unit = _( /* size unit */ "MiB"); | 157 | unit = _( /* size unit */ "TiB"); |
149 | if (size > 5 * 1024) | ||
150 | { | ||
151 | size = size / 1024; | ||
152 | unit = _( /* size unit */ "GiB"); | ||
153 | if (size > 5 * 1024) | ||
154 | { | ||
155 | size = size / 1024; | ||
156 | unit = _( /* size unit */ "TiB"); | ||
157 | } | ||
158 | } | ||
159 | } | 158 | } |
159 | } | ||
160 | } | 160 | } |
161 | } | ||
161 | ret = GNUNET_malloc (32); | 162 | ret = GNUNET_malloc (32); |
162 | GNUNET_snprintf (ret, 32, "%llu %s", size, unit); | 163 | GNUNET_snprintf (ret, 32, "%llu %s", size, unit); |
163 | return ret; | 164 | return ret; |
@@ -176,6 +177,7 @@ char * | |||
176 | GNUNET_STRINGS_to_utf8 (const char *input, size_t len, const char *charset) | 177 | GNUNET_STRINGS_to_utf8 (const char *input, size_t len, const char *charset) |
177 | { | 178 | { |
178 | char *ret; | 179 | char *ret; |
180 | |||
179 | #if ENABLE_NLS && HAVE_ICONV | 181 | #if ENABLE_NLS && HAVE_ICONV |
180 | size_t tmpSize; | 182 | size_t tmpSize; |
181 | size_t finSize; | 183 | size_t finSize; |
@@ -185,15 +187,15 @@ GNUNET_STRINGS_to_utf8 (const char *input, size_t len, const char *charset) | |||
185 | 187 | ||
186 | cd = iconv_open ("UTF-8", charset); | 188 | cd = iconv_open ("UTF-8", charset); |
187 | if (cd == (iconv_t) - 1) | 189 | if (cd == (iconv_t) - 1) |
188 | { | 190 | { |
189 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "iconv_open"); | 191 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "iconv_open"); |
190 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 192 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
191 | _("Character set requested was `%s'\n"), charset); | 193 | _("Character set requested was `%s'\n"), charset); |
192 | ret = GNUNET_malloc (len + 1); | 194 | ret = GNUNET_malloc (len + 1); |
193 | memcpy (ret, input, len); | 195 | memcpy (ret, input, len); |
194 | ret[len] = '\0'; | 196 | ret[len] = '\0'; |
195 | return ret; | 197 | return ret; |
196 | } | 198 | } |
197 | tmpSize = 3 * len + 4; | 199 | tmpSize = 3 * len + 4; |
198 | tmp = GNUNET_malloc (tmpSize); | 200 | tmp = GNUNET_malloc (tmpSize); |
199 | itmp = tmp; | 201 | itmp = tmp; |
@@ -205,15 +207,15 @@ GNUNET_STRINGS_to_utf8 (const char *input, size_t len, const char *charset) | |||
205 | (char **) &input, | 207 | (char **) &input, |
206 | #endif | 208 | #endif |
207 | &len, &itmp, &finSize) == SIZE_MAX) | 209 | &len, &itmp, &finSize) == SIZE_MAX) |
208 | { | 210 | { |
209 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "iconv"); | 211 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "iconv"); |
210 | iconv_close (cd); | 212 | iconv_close (cd); |
211 | GNUNET_free (tmp); | 213 | GNUNET_free (tmp); |
212 | ret = GNUNET_malloc (len + 1); | 214 | ret = GNUNET_malloc (len + 1); |
213 | memcpy (ret, input, len); | 215 | memcpy (ret, input, len); |
214 | ret[len] = '\0'; | 216 | ret[len] = '\0'; |
215 | return ret; | 217 | return ret; |
216 | } | 218 | } |
217 | ret = GNUNET_malloc (tmpSize - finSize + 1); | 219 | ret = GNUNET_malloc (tmpSize - finSize + 1); |
218 | memcpy (ret, tmp, tmpSize - finSize); | 220 | memcpy (ret, tmp, tmpSize - finSize); |
219 | ret[tmpSize - finSize] = '\0'; | 221 | ret[tmpSize - finSize] = '\0'; |
@@ -241,6 +243,7 @@ char * | |||
241 | GNUNET_STRINGS_filename_expand (const char *fil) | 243 | GNUNET_STRINGS_filename_expand (const char *fil) |
242 | { | 244 | { |
243 | char *buffer; | 245 | char *buffer; |
246 | |||
244 | #ifndef MINGW | 247 | #ifndef MINGW |
245 | size_t len; | 248 | size_t len; |
246 | size_t n; | 249 | size_t n; |
@@ -259,56 +262,56 @@ GNUNET_STRINGS_filename_expand (const char *fil) | |||
259 | /* absolute path, just copy */ | 262 | /* absolute path, just copy */ |
260 | return GNUNET_strdup (fil); | 263 | return GNUNET_strdup (fil); |
261 | if (fil[0] == '~') | 264 | if (fil[0] == '~') |
265 | { | ||
266 | fm = getenv ("HOME"); | ||
267 | if (fm == NULL) | ||
262 | { | 268 | { |
263 | fm = getenv ("HOME"); | 269 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
264 | if (fm == NULL) | 270 | _ |
265 | { | 271 | ("Failed to expand `$HOME': environment variable `HOME' not set")); |
266 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 272 | return NULL; |
267 | _ | ||
268 | ("Failed to expand `$HOME': environment variable `HOME' not set")); | ||
269 | return NULL; | ||
270 | } | ||
271 | fm = GNUNET_strdup (fm); | ||
272 | /* do not copy '~' */ | ||
273 | fil_ptr = fil + 1; | ||
274 | |||
275 | /* skip over dir seperator to be consistent */ | ||
276 | if (fil_ptr[0] == DIR_SEPARATOR) | ||
277 | fil_ptr++; | ||
278 | } | 273 | } |
274 | fm = GNUNET_strdup (fm); | ||
275 | /* do not copy '~' */ | ||
276 | fil_ptr = fil + 1; | ||
277 | |||
278 | /* skip over dir seperator to be consistent */ | ||
279 | if (fil_ptr[0] == DIR_SEPARATOR) | ||
280 | fil_ptr++; | ||
281 | } | ||
279 | else | 282 | else |
283 | { | ||
284 | /* relative path */ | ||
285 | fil_ptr = fil; | ||
286 | len = 512; | ||
287 | fm = NULL; | ||
288 | while (1) | ||
280 | { | 289 | { |
281 | /* relative path */ | 290 | buffer = GNUNET_malloc (len); |
282 | fil_ptr = fil; | 291 | if (getcwd (buffer, len) != NULL) |
283 | len = 512; | 292 | { |
284 | fm = NULL; | 293 | fm = buffer; |
285 | while (1) | 294 | break; |
286 | { | 295 | } |
287 | buffer = GNUNET_malloc (len); | 296 | if ((errno == ERANGE) && (len < 1024 * 1024 * 4)) |
288 | if (getcwd (buffer, len) != NULL) | 297 | { |
289 | { | 298 | len *= 2; |
290 | fm = buffer; | 299 | GNUNET_free (buffer); |
291 | break; | 300 | continue; |
292 | } | 301 | } |
293 | if ((errno == ERANGE) && (len < 1024 * 1024 * 4)) | 302 | GNUNET_free (buffer); |
294 | { | 303 | break; |
295 | len *= 2; | 304 | } |
296 | GNUNET_free (buffer); | 305 | if (fm == NULL) |
297 | continue; | 306 | { |
298 | } | 307 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "getcwd"); |
299 | GNUNET_free (buffer); | 308 | buffer = getenv ("PWD"); /* alternative */ |
300 | break; | 309 | if (buffer != NULL) |
301 | } | 310 | fm = GNUNET_strdup (buffer); |
302 | if (fm == NULL) | ||
303 | { | ||
304 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "getcwd"); | ||
305 | buffer = getenv ("PWD"); /* alternative */ | ||
306 | if (buffer != NULL) | ||
307 | fm = GNUNET_strdup (buffer); | ||
308 | } | ||
309 | if (fm == NULL) | ||
310 | fm = GNUNET_strdup ("./"); /* give up */ | ||
311 | } | 311 | } |
312 | if (fm == NULL) | ||
313 | fm = GNUNET_strdup ("./"); /* give up */ | ||
314 | } | ||
312 | n = strlen (fm) + 1 + strlen (fil_ptr) + 1; | 315 | n = strlen (fm) + 1 + strlen (fil_ptr) + 1; |
313 | buffer = GNUNET_malloc (n); | 316 | buffer = GNUNET_malloc (n); |
314 | GNUNET_snprintf (buffer, n, "%s%s%s", | 317 | GNUNET_snprintf (buffer, n, "%s%s%s", |
@@ -321,29 +324,28 @@ GNUNET_STRINGS_filename_expand (const char *fil) | |||
321 | fn = GNUNET_malloc (MAX_PATH + 1); | 324 | fn = GNUNET_malloc (MAX_PATH + 1); |
322 | 325 | ||
323 | if ((lRet = plibc_conv_to_win_path (fil, fn)) != ERROR_SUCCESS) | 326 | if ((lRet = plibc_conv_to_win_path (fil, fn)) != ERROR_SUCCESS) |
324 | { | 327 | { |
325 | SetErrnoFromWinError (lRet); | 328 | SetErrnoFromWinError (lRet); |
326 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, | 329 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "plibc_conv_to_win_path"); |
327 | "plibc_conv_to_win_path"); | 330 | return NULL; |
328 | return NULL; | 331 | } |
329 | } | ||
330 | /* is the path relative? */ | 332 | /* is the path relative? */ |
331 | if ((strncmp (fn + 1, ":\\", 2) != 0) && (strncmp (fn, "\\\\", 2) != 0)) | 333 | if ((strncmp (fn + 1, ":\\", 2) != 0) && (strncmp (fn, "\\\\", 2) != 0)) |
334 | { | ||
335 | char szCurDir[MAX_PATH + 1]; | ||
336 | |||
337 | lRet = GetCurrentDirectory (MAX_PATH + 1, szCurDir); | ||
338 | if (lRet + strlen (fn) + 1 > (MAX_PATH + 1)) | ||
332 | { | 339 | { |
333 | char szCurDir[MAX_PATH + 1]; | 340 | SetErrnoFromWinError (ERROR_BUFFER_OVERFLOW); |
334 | lRet = GetCurrentDirectory (MAX_PATH + 1, szCurDir); | 341 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "GetCurrentDirectory"); |
335 | if (lRet + strlen (fn) + 1 > (MAX_PATH + 1)) | 342 | return NULL; |
336 | { | ||
337 | SetErrnoFromWinError (ERROR_BUFFER_OVERFLOW); | ||
338 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, | ||
339 | "GetCurrentDirectory"); | ||
340 | return NULL; | ||
341 | } | ||
342 | buffer = GNUNET_malloc (MAX_PATH + 1); | ||
343 | GNUNET_snprintf (buffer, MAX_PATH + 1, "%s\\%s", szCurDir, fn); | ||
344 | GNUNET_free (fn); | ||
345 | fn = buffer; | ||
346 | } | 343 | } |
344 | buffer = GNUNET_malloc (MAX_PATH + 1); | ||
345 | GNUNET_snprintf (buffer, MAX_PATH + 1, "%s\\%s", szCurDir, fn); | ||
346 | GNUNET_free (fn); | ||
347 | fn = buffer; | ||
348 | } | ||
347 | 349 | ||
348 | return fn; | 350 | return fn; |
349 | #endif | 351 | #endif |
@@ -366,25 +368,25 @@ GNUNET_STRINGS_relative_time_to_string (struct GNUNET_TIME_Relative delta) | |||
366 | if (delta.rel_value == GNUNET_TIME_UNIT_FOREVER_REL.rel_value) | 368 | if (delta.rel_value == GNUNET_TIME_UNIT_FOREVER_REL.rel_value) |
367 | return GNUNET_strdup (_("eternity")); | 369 | return GNUNET_strdup (_("eternity")); |
368 | if (dval > 5 * 1000) | 370 | if (dval > 5 * 1000) |
371 | { | ||
372 | dval = dval / 1000; | ||
373 | unit = _( /* time unit */ "s"); | ||
374 | if (dval > 5 * 60) | ||
369 | { | 375 | { |
370 | dval = dval / 1000; | 376 | dval = dval / 60; |
371 | unit = _( /* time unit */ "s"); | 377 | unit = _( /* time unit */ "m"); |
372 | if (dval > 5 * 60) | 378 | if (dval > 5 * 60) |
379 | { | ||
380 | dval = dval / 60; | ||
381 | unit = _( /* time unit */ "h"); | ||
382 | if (dval > 5 * 24) | ||
373 | { | 383 | { |
374 | dval = dval / 60; | 384 | dval = dval / 24; |
375 | unit = _( /* time unit */ "m"); | 385 | unit = _( /* time unit */ " days"); |
376 | if (dval > 5 * 60) | ||
377 | { | ||
378 | dval = dval / 60; | ||
379 | unit = _( /* time unit */ "h"); | ||
380 | if (dval > 5 * 24) | ||
381 | { | ||
382 | dval = dval / 24; | ||
383 | unit = _( /* time unit */ " days"); | ||
384 | } | ||
385 | } | ||
386 | } | 386 | } |
387 | } | ||
387 | } | 388 | } |
389 | } | ||
388 | GNUNET_asprintf (&ret, "%llu %s", dval, unit); | 390 | GNUNET_asprintf (&ret, "%llu %s", dval, unit); |
389 | return ret; | 391 | return ret; |
390 | } | 392 | } |