Macintosh-Tools/Retro68
1
0
Fork 0
mirror of https://github.com/autc04/Retro68.git synced 2024-06-07 13:33:06 +00:00
Code Issues Projects Releases Wiki Activity
master
Retro68/binutils/gprofng/src/util.cc
Wolfgang Thaller f485e125c4 binutils 2.39
2022-10-27 20:45:45 +02:00

1583 lines
39 KiB
C++
Raw Permalink Blame History

/* Copyright (C) 2021 Free Software Foundation, Inc.
Contributed by Oracle.
This file is part of GNU Binutils.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, 51 Franklin Street - Fifth Floor, Boston,
MA 02110-1301, USA. */
#include "config.h"
#include <sys/param.h>
#include <stdarg.h>
#include <unistd.h>
#include <dirent.h> // readdir()
#include <sys/param.h> // MAXPATHLEN
#include <pthread.h> // mutex
#include <libgen.h> // dirname
#include <sys/types.h> // open
#include <sys/stat.h> // open
#include <errno.h> // errno
#include <fcntl.h> // open
#include "util.h"
#include "dbe_structs.h"
#include "StringBuilder.h"
#include "StringMap.h" // For directory names
#include "Application.h" // Only for get_prog_name
#include "vec.h"
void
tsadd (timestruc_t *result, timestruc_t *time)
{
// This routine will add "time" to "result".
result->tv_sec += time->tv_sec;
result->tv_nsec += time->tv_nsec;
if (result->tv_nsec >= NANOSEC)
{
result->tv_nsec -= NANOSEC;
result->tv_sec++;
}
}
void
tssub (timestruc_t *result, timestruc_t *time1, timestruc_t *time2)
{
// This routine will store "time1" - "time2" in "result".
if (time1->tv_nsec >= time2->tv_nsec)
{
result->tv_nsec = time1->tv_nsec - time2->tv_nsec;
if (time1->tv_sec >= time2->tv_sec)
result->tv_sec = time1->tv_sec - time2->tv_sec;
else
{
result->tv_sec = -1;
result->tv_nsec = 0;
}
}
else
{
result->tv_nsec = time1->tv_nsec + NANOSEC - time2->tv_nsec;
if (time1->tv_sec - 1 >= time2->tv_sec)
result->tv_sec = time1->tv_sec - 1 - time2->tv_sec;
else
{
result->tv_sec = -1;
result->tv_nsec = 0;
}
}
}
int
tscmp (timestruc_t *time1, timestruc_t *time2)
{
// This routine will return 1 if "time1" is greater than "time2"
// and 0 if "time1" is equal to "time2" and -1 otherwise.
if (time1->tv_sec == time2->tv_sec)
return time1->tv_nsec > time2->tv_nsec ? 1 :
time1->tv_nsec == time2->tv_nsec ? 0 : -1;
else
return time1->tv_sec > time2->tv_sec ? 1 : -1;
}
void
int_max (int *maximum, int count)
{
if (count > *maximum)
*maximum = count;
}
double
TValue::to_double ()
{
switch (tag)
{
case VT_DOUBLE:
return (double) d;
case VT_INT:
return (double) i;
case VT_ULLONG:
return (double) ull;
case VT_LLONG:
case VT_ADDRESS:
return (double) ll;
case VT_FLOAT:
return (double) f;
case VT_SHORT:
return (double) s;
default:
return 0.0;
}
}
int
TValue::to_int ()
{
switch (tag)
{
case VT_DOUBLE:
return (int) d;
case VT_INT:
return (int) i;
case VT_ULLONG:
return (int) ull;
case VT_LLONG:
case VT_ADDRESS:
return (int) ll;
case VT_FLOAT:
return (int) f;
case VT_SHORT:
return (int) s;
default:
return 0;
}
}
size_t
TValue::get_len ()
{
char buf[256];
return strlen (to_str (buf, sizeof (buf)));
}
char *
TValue::to_str (char *str, size_t strsz)
{
switch (tag)
{
case VT_DOUBLE:
if (d == 0.)
{
if (sign)
snprintf (str, strsz, NTXT ("+0. "));
else
snprintf (str, strsz, NTXT ("0. "));
}
else if (sign)
snprintf (str, strsz, NTXT ("%+.3lf"), d);
else
snprintf (str, strsz, NTXT ("%.3lf"), d);
break;
case VT_INT:
snprintf (str, strsz, NTXT ("%u"), i);
break;
case VT_LLONG:
if (sign)
snprintf (str, strsz, NTXT ("%+lld"), ll);
else
snprintf (str, strsz, NTXT ("%lld"), ll);
break;
case VT_ULLONG:
snprintf (str, strsz, NTXT ("%llu"), ll);
break;
case VT_ADDRESS:
snprintf (str, strsz, NTXT ("%u:0x%08x"), ADDRESS_SEG (ll), ADDRESS_OFF (ll));
break;
case VT_FLOAT:
snprintf (str, strsz, NTXT ("%.3f"), f);
break;
case VT_SHORT:
snprintf (str, strsz, NTXT ("%hu"), s);
break;
case VT_LABEL:
return l; // 'str' is not used !!!
default:
*str = '\0';
break;
}
return str;
}
void
TValue::make_delta (TValue *v1, TValue *v2)
{
assert (v1->tag == v2->tag);
tag = v1->tag;
sign = true;
switch (v1->tag)
{
case VT_INT:
i = v1->i - v2->i;
break;
case VT_LLONG:
ll = v1->ll - v2->ll;
break;
case VT_ULLONG:
case VT_ADDRESS:
tag = VT_LLONG;
ll = (long long) (v1->ull - v2->ull);
break;
case VT_FLOAT:
f = v1->f - v2->f;
break;
case VT_DOUBLE:
d = v1->d - v2->d;
break;
default:
assert (0);
break;
}
}
void
TValue::make_ratio (TValue *v1, TValue *v2)
{
assert (v1->tag == v2->tag);
double x1 = v1->to_double ();
double x2 = v2->to_double ();
sign = false;
if (x1 == 0.)
{
// if the numerator is 0, the ratio is 1. or 0. only
d = (x2 == 0.) ? 1. : 0.;
tag = VT_DOUBLE;
}
else
{
// EUGENE replace 99.999 with a variable that is known by both DBE and GUI
if (x1 > 99.999 * x2)
{
l = dbe_strdup (">99.999");
tag = VT_LABEL;
}
else if (x1 < -99.999 * x2)
{
l = dbe_strdup ("<-99.999");
tag = VT_LABEL;
}
else
{
d = x1 / x2;
tag = VT_DOUBLE;
}
}
}
int
TValue::compare (TValue *v)
{
if (tag != v->tag)
{ // Only for comparison (Ratio)
if (tag == VT_LABEL)
{
if (v->tag == VT_LABEL)
return strcoll (l, v->l);
return 1;
}
if (v->tag == VT_LABEL)
return -1;
return ll < v->ll ? -1 : (ll == v->ll ? 0 : 1);
}
switch (tag)
{
case VT_SHORT:
return s < v->s ? -1 : (s == v->s ? 0 : 1);
case VT_INT:
return i < v->i ? -1 : (i == v->i ? 0 : 1);
case VT_FLOAT:
return f < v->f ? -1 : (f == v->f ? 0 : 1);
case VT_DOUBLE:
return d < v->d ? -1 : (d == v->d ? 0 : 1);
case VT_LABEL:
return strcoll (l, v->l);
case VT_LLONG:
case VT_ULLONG:
case VT_ADDRESS:
case VT_HRTIME:
default:
return (ll < v->ll) ? -1 : ((ll == v->ll) ? 0 : 1);
}
}
char *
strstr_r (char *s1, const char *s2)
{
char *str = NULL;
for (char *s = s1; s;)
{
s = strstr (s, s2);
if (s)
{
str = s;
s++;
}
}
return str;
}
// reversal order of strpbrk
char *
strrpbrk (const char *string, const char *brkset)
{
const char *p;
const char *s;
for (s = string + strlen (string) - 1; s >= string; s--)
{
for (p = brkset; *p != '\0' && *p != *s; ++p)
;
if (*p != '\0')
return ((char *) s);
}
return NULL;
}
char *
read_line (FILE *fptr)
{
// get an input line, no size limit
int line_sz = 128; // starting size
char *line = (char *) malloc (line_sz);
// read as much of the line as will fit in memory
line[0] = 0;
int len = 0;
for (;;)
{
while (fgets (line + len, line_sz - len, fptr) != NULL)
{
len = (int) strlen (line);
if (len == 0 || line[len - 1] == '\n')
break;
// increase the buffer
char *lineNew = (char *) malloc (2 * line_sz);
strncpy (lineNew, line, line_sz);
lineNew[line_sz] = '\0';
free (line);
line = lineNew;
line_sz *= 2;
if (line == NULL)
{
fprintf (stderr, GTXT (" Line too long -- out of memory; exiting\n"));
exit (1);
}
}
if (len == 0)
{
free (line);
return NULL;
}
// see if there's a continuation line
if ((len >= 2) && (line[len - 1] == '\n') && (line[len - 2] == '\\'))
{
// remove the trailing \ and the \n, and keep going
line[len - 2] = 0;
len -= 2;
}
else
break;
}
return line; // expecting the caller to free it
}
Vector<char *> *
split_str (char *str, char delimiter)
{
Vector<char *> *v = new Vector<char *>;
for (char *s = str; s;)
{
if (*s == '"')
{
char *next_s = NULL;
char *tok = parse_qstring (s, &next_s);
if (tok && *tok != '\0')
v->append (tok);
if (*next_s)
s = next_s + 1;
else
s = NULL;
}
else
{
char *next_s = strchr (s, delimiter);
if (next_s)
{
if (next_s != s)
v->append (dbe_strndup (s, next_s - s));
s = next_s + 1;
}
else
{
if (*s != '\0')
v->append (dbe_strdup (s));
s = NULL;
}
}
}
return v;
}
// get quoted string
char *
parse_qstring (char *in_str, char **endptr)
{
int i;
char c, c2;
char term;
char csnum[2 * MAXPATHLEN];
// Skip any leading blanks or tabs
while (*in_str == '\t' || *in_str == ' ')
in_str++;
int gtxt = 0;
if (*in_str == 'G' && *(in_str + 1) == 'T' && *(in_str + 2) == 'X'
&& *(in_str + 3) == 'T' && *(in_str + 4) == '(')
{
gtxt = 1;
in_str += 5;
}
// non-quoted string
if (*in_str == '"')
term = '"';
else if (*in_str == '\'')
term = '\'';
else
return strtok_r (in_str, NTXT (" "), endptr);
StringBuilder sb;
while ((c = *(++in_str)) != '\0')
{
if (c == term) // the closing quote
break;
if (c == '\\')
{ // handle any escaped characters
c2 = *(++in_str);
switch (c2)
{
case '\"':
sb.append ('\"');
break;
case '\'':
sb.append ('\'');
break;
case '\\':
sb.append ('\\');
break;
case 't':
sb.append ('\t');
break;
case 'r':
sb.append ('\r');
break;
case 'b':
sb.append ('\b');
break;
case 'f':
sb.append ('\f');
break;
case 'n':
sb.append ('\n');
break;
default:
if ((c2 >= '0') && (c2 <= '9'))
{
for (i = 0; i < MAXPATHLEN; i++)
{
if (((c2 < '0') || (c2 > '9')) && (c2 != 'x') &&
((c2 < 'a') || (c2 > 'f')) &&
((c2 < 'A') || (c2 > 'F')))
{
csnum[i] = '\0';
--in_str;
break;
}
else
{
csnum[i] = c2;
c2 = *(++in_str);
}
}
sb.append ((char) strtoul (csnum, endptr, 0));
}
else
sb.append (c2);
break;
}
}
else
sb.append (c);
}
if (c == term && gtxt && *in_str == ')')
in_str++;
if (*in_str == '\0')
*endptr = in_str;
else
*endptr = in_str + 1;
return sb.toString ();
}
// parse a file name of the form name`name2`
// returns name
// stores the pointer to named in fcontext
// returns NULL if the string is not properly formatted
char *
parse_fname (char *in_str, char **fcontext)
{
*fcontext = NULL;
int ch = '`';
if (in_str == NULL)
return NULL;
char *copy = strdup (in_str);
char *p = strchr (copy, ch);
if (p != NULL)
{
// yes, there's an embedded file name
*p = '\0';
p++;
// now find the terminating single quote
char *p1 = strchr (p, ch);
if (p1 == NULL)
{
// if we don't have the closing `, the format is incorrect
free (copy);
return NULL;
}
//remove the closing quote
*p1 = '\0';
// see if there's anything following it
if (*(p1 + 1) != 0)
{
// error in format
free (copy);
return NULL;
}
free (*fcontext);
*fcontext = strdup (p);
}
return copy;
}
int
get_paren (const char *name)
{
char buf[8192];
char *ptr;
int temp_level1, temp_level2;
temp_level1 = temp_level2 = 0;
snprintf (buf, sizeof (buf), NTXT ("%s"), name);
while ((ptr = strrpbrk (buf, "><)(")) != NULL)
{
if (*ptr == '>')
temp_level1++;
else if (*ptr == '<')
temp_level1--;
else if (*ptr == ')')
temp_level2++;
else
{
temp_level2--;
if (temp_level1 <= 0 && temp_level2 <= 0)
return (int) (ptr - buf);
}
*ptr = '\0';
}
return -1;
}
// CRC-64 based on x^64 + x^11 + x^2 + x + 1 polynomial.
// This algorithm doesn't perform well but is short and
// readable. We currently use it for a small amount of
// short strings. Should this change, another algorithm
// with better performance is to be used instead.
static uint64_t masks[256] = {
/* 0 */ 0x000000, 0x000807, 0x00100e, 0x001809, 0x00201c, 0x00281b,
/* 6 */ 0x003012, 0x003815, 0x004038, 0x00483f, 0x005036, 0x005831,
/* 12 */ 0x006024, 0x006823, 0x00702a, 0x00782d, 0x008070, 0x008877,
/* 18 */ 0x00907e, 0x009879, 0x00a06c, 0x00a86b, 0x00b062, 0x00b865,
/* 24 */ 0x00c048, 0x00c84f, 0x00d046, 0x00d841, 0x00e054, 0x00e853,
/* 30 */ 0x00f05a, 0x00f85d, 0x0100e0, 0x0108e7, 0x0110ee, 0x0118e9,
/* 36 */ 0x0120fc, 0x0128fb, 0x0130f2, 0x0138f5, 0x0140d8, 0x0148df,
/* 42 */ 0x0150d6, 0x0158d1, 0x0160c4, 0x0168c3, 0x0170ca, 0x0178cd,
/* 48 */ 0x018090, 0x018897, 0x01909e, 0x019899, 0x01a08c, 0x01a88b,
/* 54 */ 0x01b082, 0x01b885, 0x01c0a8, 0x01c8af, 0x01d0a6, 0x01d8a1,
/* 60 */ 0x01e0b4, 0x01e8b3, 0x01f0ba, 0x01f8bd, 0x0201c0, 0x0209c7,
/* 66 */ 0x0211ce, 0x0219c9, 0x0221dc, 0x0229db, 0x0231d2, 0x0239d5,
/* 72 */ 0x0241f8, 0x0249ff, 0x0251f6, 0x0259f1, 0x0261e4, 0x0269e3,
/* 78 */ 0x0271ea, 0x0279ed, 0x0281b0, 0x0289b7, 0x0291be, 0x0299b9,
/* 84 */ 0x02a1ac, 0x02a9ab, 0x02b1a2, 0x02b9a5, 0x02c188, 0x02c98f,
/* 90 */ 0x02d186, 0x02d981, 0x02e194, 0x02e993, 0x02f19a, 0x02f99d,
/* 96 */ 0x030120, 0x030927, 0x03112e, 0x031929, 0x03213c, 0x03293b,
/* 102 */ 0x033132, 0x033935, 0x034118, 0x03491f, 0x035116, 0x035911,
/* 108 */ 0x036104, 0x036903, 0x03710a, 0x03790d, 0x038150, 0x038957,
/* 114 */ 0x03915e, 0x039959, 0x03a14c, 0x03a94b, 0x03b142, 0x03b945,
/* 120 */ 0x03c168, 0x03c96f, 0x03d166, 0x03d961, 0x03e174, 0x03e973,
/* 126 */ 0x03f17a, 0x03f97d, 0x040380, 0x040b87, 0x04138e, 0x041b89,
/* 132 */ 0x04239c, 0x042b9b, 0x043392, 0x043b95, 0x0443b8, 0x044bbf,
/* 138 */ 0x0453b6, 0x045bb1, 0x0463a4, 0x046ba3, 0x0473aa, 0x047bad,
/* 144 */ 0x0483f0, 0x048bf7, 0x0493fe, 0x049bf9, 0x04a3ec, 0x04abeb,
/* 150 */ 0x04b3e2, 0x04bbe5, 0x04c3c8, 0x04cbcf, 0x04d3c6, 0x04dbc1,
/* 156 */ 0x04e3d4, 0x04ebd3, 0x04f3da, 0x04fbdd, 0x050360, 0x050b67,
/* 162 */ 0x05136e, 0x051b69, 0x05237c, 0x052b7b, 0x053372, 0x053b75,
/* 168 */ 0x054358, 0x054b5f, 0x055356, 0x055b51, 0x056344, 0x056b43,
/* 174 */ 0x05734a, 0x057b4d, 0x058310, 0x058b17, 0x05931e, 0x059b19,
/* 180 */ 0x05a30c, 0x05ab0b, 0x05b302, 0x05bb05, 0x05c328, 0x05cb2f,
/* 186 */ 0x05d326, 0x05db21, 0x05e334, 0x05eb33, 0x05f33a, 0x05fb3d,
/* 192 */ 0x060240, 0x060a47, 0x06124e, 0x061a49, 0x06225c, 0x062a5b,
/* 198 */ 0x063252, 0x063a55, 0x064278, 0x064a7f, 0x065276, 0x065a71,
/* 204 */ 0x066264, 0x066a63, 0x06726a, 0x067a6d, 0x068230, 0x068a37,
/* 210 */ 0x06923e, 0x069a39, 0x06a22c, 0x06aa2b, 0x06b222, 0x06ba25,
/* 216 */ 0x06c208, 0x06ca0f, 0x06d206, 0x06da01, 0x06e214, 0x06ea13,
/* 222 */ 0x06f21a, 0x06fa1d, 0x0702a0, 0x070aa7, 0x0712ae, 0x071aa9,
/* 228 */ 0x0722bc, 0x072abb, 0x0732b2, 0x073ab5, 0x074298, 0x074a9f,
/* 234 */ 0x075296, 0x075a91, 0x076284, 0x076a83, 0x07728a, 0x077a8d,
/* 240 */ 0x0782d0, 0x078ad7, 0x0792de, 0x079ad9, 0x07a2cc, 0x07aacb,
/* 246 */ 0x07b2c2, 0x07bac5, 0x07c2e8, 0x07caef, 0x07d2e6, 0x07dae1,
/* 252 */ 0x07e2f4, 0x07eaf3, 0x07f2fa, 0x07fafd
};
uint64_t
crc64 (const char *str, size_t len)
{
uint64_t res = 0LL;
for (size_t i = 0; i < len; i++)
{
unsigned char b = (unsigned char) ((res >> 56) ^ *str++);
res = res << 8;
res ^= masks [b];
}
return res;
}
/**
* Canonize path inside the string provided by the argument
* @param path
* @return path
*/
char *
canonical_path (char *path)
{
char *s1, *s2;
if (!path)
return path;
s1 = path;
s2 = path;
while (*s1)
{
if (*s1 == '.' && s1[1] == '/')
{ // remove .///
for (s1++; *s1; s1++)
if (*s1 != '/')
break;
}
else if (*s1 == '/')
{ // replace /// with /
*(s2++) = *s1;
for (s1++; *s1; s1++)
if (*s1 != '/')
break;
}
else
{
while (*s1)
{ // copy file or directory name
if (*s1 == '/')
break;
*(s2++) = *(s1++);
}
}
}
*s2 = 0;
if (s2 != path && (s2 - 1) != path && s2[-1] == '/') // remove last /
*(s2 - 1) = 0;
return path;
}
char *
get_relative_path (char *name)
{
if (*name == '/' && theApplication)
{
char *cwd = theApplication->get_cur_dir ();
if (cwd)
{
size_t len = strlen (cwd);
if (len > 0 && len < strlen (name) && name[len] == '/'
&& strncmp (cwd, name, len) == 0)
{
for (name += len + 1; *name == '/'; name++)
;
return name;
}
}
}
return name;
}
/**
* Generate a relative link name from path_from to path_to
* Example:
* path_from=a/b/c/d
* path_to=a/b/e/f/g
* lname=../../e/f/g
* @param path_to
* @param path_from
* @return lname - relative link
*/
char *
get_relative_link (const char *path_from, const char *path_to)
{
if (!path_to)
path_to = ".";
if (!path_from)
path_from = ".";
char *s1 = dbe_strdup (path_to);
s1 = canonical_path (s1);
char *s2 = dbe_strdup (path_from);
s2 = canonical_path (s2);
long l = dbe_sstrlen (s1);
// try to find common directories
int common_slashes = 0;
int last_common_slash = -1;
for (int i = 0; i < l; i++)
{
if (s1[i] != s2[i]) break;
if (s1[i] == 0) break;
if (s1[i] == '/')
{
common_slashes++;
last_common_slash = i;
}
}
// find slashes in remaining path_to
int slashes = 0;
for (int i = last_common_slash + 1; i < l; i++)
{
if (s1[i] == '/')
{
// Exclude "/./" case
if (i > last_common_slash + 2)
{
if (s1[i - 1] == '.' && s1[i - 2] == '/')
continue;
}
else if (i > 0 && s1[i - 1] == '.')
continue;
slashes++;
}
}
// generate relative path
StringBuilder sb;
for (int i = 0; i < slashes; i++)
sb.append ("../");
sb.append (s2 + last_common_slash + 1);
char *lname = sb.toString ();
free (s1);
free (s2);
return lname;
}
char *
get_prog_name (int basename)
{
char *nm = NULL;
if (theApplication)
{
nm = theApplication->get_name ();
if (nm && basename)
nm = get_basename (nm);
}
return nm;
}
char *
dbe_strndup (const char *str, size_t len)
{
if (str == NULL)
return NULL;
char *s = (char *) malloc (len + 1);
strncpy (s, str, len);
s[len] = '\0';
return s;
}
char *
dbe_sprintf (const char *fmt, ...)
{
char buffer[256];
int buf_size;
va_list vp;
va_start (vp, fmt);
buf_size = vsnprintf (buffer, sizeof (buffer), fmt, vp) + 1;
va_end (vp);
if (buf_size < (int) sizeof (buffer))
{
if (buf_size <= 1)
buffer[0] = 0;
return strdup (buffer);
}
va_start (vp, fmt);
char *buf = (char *) malloc (buf_size);
vsnprintf (buf, buf_size, fmt, vp);
va_end (vp);
return buf;
}
ssize_t
dbe_write (int f, const char *fmt, ...)
{
char buffer[256];
int buf_size;
va_list vp;
va_start (vp, fmt);
buf_size = vsnprintf (buffer, sizeof (buffer), fmt, vp) + 1;
va_end (vp);
if (buf_size < (int) sizeof (buffer))
{
if (buf_size <= 1)
buffer[0] = 0;
return write (f, buffer, strlen (buffer));
}
va_start (vp, fmt);
char *buf = (char *) malloc (buf_size);
vsnprintf (buf, buf_size, fmt, vp);
va_end (vp);
ssize_t val = write (f, buf, strlen (buf));
free (buf);
return val;
}
/* Worker Threads to avoid hanging on file servers */
/*
* Thread states
*/
enum
{
THREAD_START,
THREAD_STARTED,
THREAD_CANCEL,
THREAD_CANCELED,
THREAD_CREATE,
THREAD_NOT_CREATED,
THREAD_FINISHED
};
/*
* Communication structure
*/
struct worker_thread_info
{
pthread_t thread_id; /* ID returned by pthread_create() */
int thread_num; /* Application-defined thread # */
volatile int control; /* Thread state */
volatile int result; /* Return status */
struct stat64 statbuf; /* File info from stat64() */
const char *path; /* File */
};
static pthread_mutex_t worker_thread_lock = PTHREAD_MUTEX_INITIALIZER;
static int worker_thread_number = 0;
/**
* Call stat64() on current worker thread
* Check if control is not THREAD_CANCEL
* If control is THREAD_CANCEL return (exit thread)
* @param *wt_info
*/
static void *
dbe_stat_on_thread (void *arg)
{
struct worker_thread_info *wt_info = (struct worker_thread_info *) arg;
pthread_mutex_lock (&worker_thread_lock);
{
if (wt_info->control != THREAD_START)
{
// Already too late
pthread_mutex_unlock (&worker_thread_lock);
return 0;
}
wt_info->control = THREAD_STARTED;
}
pthread_mutex_unlock (&worker_thread_lock);
const char * path = wt_info->path;
int st = stat64 (path, &(wt_info->statbuf));
pthread_mutex_lock (&worker_thread_lock);
{
if (wt_info->control == THREAD_CANCEL)
{
// Too late.
pthread_mutex_unlock (&worker_thread_lock);
free (wt_info);
return 0;
}
wt_info->result = st;
wt_info->control = THREAD_FINISHED;
}
pthread_mutex_unlock (&worker_thread_lock);
return 0;
}
/**
* Create a worker thread to call specified function
* Wait for its result, but not longer than 5 seconds
* If the timeout happens, tell the thread to cancel
* @param path
* @param wt_info
* @return thread state
*/
static int
dbe_dispatch_on_thread (const char *path, struct worker_thread_info *wt_info)
{
wt_info->result = 0;
wt_info->control = THREAD_START;
pthread_attr_t attr;
/* Initialize thread creation attributes */
int res = pthread_attr_init (&attr);
if (res != 0)
{
wt_info->control = THREAD_NOT_CREATED;
return THREAD_NOT_CREATED;
}
wt_info->thread_id = 0;
wt_info->path = path;
// Lock
pthread_mutex_lock (&worker_thread_lock);
worker_thread_number++;
wt_info->thread_num = worker_thread_number;
// Unlock
pthread_mutex_unlock (&worker_thread_lock);
// Create thread
res = pthread_create (&wt_info->thread_id, &attr, &dbe_stat_on_thread, wt_info);
if (res != 0)
{
wt_info->control = THREAD_NOT_CREATED;
pthread_attr_destroy (&attr);
return THREAD_NOT_CREATED;
}
// Wait for the thread to finish
res = 0;
useconds_t maxusec = 5000000; // 5 seconds
useconds_t deltausec = 1000; // 1 millisecond
int max = maxusec / deltausec;
for (int i = 0; i < max; i++)
{
if (THREAD_FINISHED == wt_info->control)
break; // We are done
usleep (deltausec);
}
// Lock
pthread_mutex_lock (&worker_thread_lock);
if (THREAD_FINISHED != wt_info->control)
{
// Cancel thread
wt_info->control = THREAD_CANCEL; // Cannot use wt_info after that!
res = THREAD_CANCEL;
}
// Unlock
pthread_mutex_unlock (&worker_thread_lock);
// Destroy the thread attributes object, since it is no longer needed
pthread_attr_destroy (&attr);
// Report that thread was canceled
if (THREAD_CANCEL == res)
return res; /* Cannot free memory allocated by thread */
// Free all thread resources
void *resources = 0;
res = pthread_join (wt_info->thread_id, &resources);
free (resources); /* Free memory allocated by thread */
return THREAD_FINISHED;
}
static pthread_mutex_t dirnames_lock = PTHREAD_MUTEX_INITIALIZER;
static Map<const char*, int> *dirnamesMap = NULL;
#define DIR_STATUS_EXISTS 0
#define DIR_STATUS_UNKNOWN 2
/**
* Check if this directory name is known
* Return:
* @param path
* 0 - known, exists
* 1 - known, does not exist
* 2 - not known
*/
static int
check_dirname (const char *path)
{
pthread_mutex_lock (&dirnames_lock);
if (NULL == dirnamesMap)
dirnamesMap = new StringMap<int>(128, 128);
pthread_mutex_unlock (&dirnames_lock);
int res = DIR_STATUS_UNKNOWN;
if (path && *path)
{
char *fn = dbe_strdup (path);
char *dn = dirname (fn);
if (dn && *dn)
res = dirnamesMap->get (dn);
free (fn);
}
return res;
}
/**
* Save directory name and its status
* @param path
* @param status
* @return
*/
static void
extract_and_save_dirname (const char *path, int status)
{
pthread_mutex_lock (&dirnames_lock);
if (NULL == dirnamesMap)
dirnamesMap = new StringMap<int>(128, 128);
pthread_mutex_unlock (&dirnames_lock);
char *fn = dbe_strdup (path);
if (fn && *fn != 0)
{
char *dn = dirname (fn);
if (dn && (*dn != 0))
{
int st = 0; // exists
if (0 != status)
st = 1; // does not exist
dirnamesMap->put (dn, st);
}
}
free (fn);
}
// get status for specified file
static int
dbe_stat_internal (const char *path, struct stat64 *sbuf, bool file_only)
{
struct stat64 statbuf;
int dir_status = check_dirname (path);
if (dir_status == DIR_STATUS_UNKNOWN)
{
// Try to use a worker thread
if (theApplication->get_number_of_worker_threads () > 0)
{
struct worker_thread_info *wt_info;
wt_info = (worker_thread_info *) calloc (1, sizeof (worker_thread_info));
if (wt_info != NULL)
{
int res = dbe_dispatch_on_thread (path, wt_info);
if (THREAD_FINISHED == res)
{
int st = wt_info->result;
extract_and_save_dirname (path, st);
if (st == 0 && file_only)
if (S_ISREG ((wt_info->statbuf).st_mode) == 0)
st = -1; // It is not a regular file
if (sbuf != NULL)
*sbuf = wt_info->statbuf;
free (wt_info);
return st;
}
else
{
if (THREAD_CANCEL == res)
{
// Worker thread hung. Cannot free wt_info.
// Allocated memory will be freed by worker thread.
// save directory
extract_and_save_dirname (path, 1);
return 1; // stat64 failed
}
else // THREAD_NOT_CREATED - continue on current thread
free (wt_info);
}
}
}
}
else if (dir_status != DIR_STATUS_EXISTS)
return -1; // does not exist
if (sbuf == NULL)
sbuf = &statbuf;
int st = stat64 (path, sbuf);
Dprintf (DEBUG_DBE_FILE, NTXT ("dbe_stat %d '%s'\n"), st, path);
if (st == -1)
return -1;
else if (file_only && S_ISREG (sbuf->st_mode) == 0)
return -1; // It is not ordinary file
return st;
}
// get status for the regular file
int
dbe_stat_file (const char *path, struct stat64 *sbuf)
{
int res = dbe_stat_internal (path, sbuf, true);
return res;
}
// get status for specified file
int
dbe_stat (const char *path, struct stat64 *sbuf)
{
int res = dbe_stat_internal (path, sbuf, false);
return res;
}
/**
* Reads directory and prepares list of files according to the specified format
* Supported formats:
* "/bin/ls -a" - see 'man ls' for details
* "/bin/ls -aF" - see 'man ls' for details
* @param path
* @param format
* @return char * files
*/
char *
dbe_read_dir (const char *path, const char *format)
{
StringBuilder sb;
DIR *dir = opendir (path);
if (dir == NULL)
return sb.toString ();
int format_aF = 0;
if (!strcmp (format, NTXT ("/bin/ls -aF")))
format_aF = 1;
struct dirent *entry = NULL;
if (format != NULL)
{
while ((entry = readdir (dir)) != NULL)
{
sb.append (entry->d_name);
if (format_aF)
{
const char *attr = NTXT ("@"); // Link
struct stat64 sbuf;
sbuf.st_mode = 0;
char filename[MAXPATHLEN + 1];
snprintf (filename, sizeof (filename), NTXT ("%s/%s"), path, entry->d_name);
dbe_stat (filename, &sbuf);
if (S_IREAD & sbuf.st_mode)
{ // Readable
if (S_ISDIR (sbuf.st_mode) != 0) // Directory
attr = NTXT ("/");
else if (S_ISREG (sbuf.st_mode) != 0) // Regular file
attr = NTXT ("");
}
sb.append (attr);
}
sb.append (NTXT ("\n"));
}
}
closedir (dir);
return sb.toString ();
}
/**
* Gets list of processes according to the specified format
* Supported formats:
* "/bin/ps -ef" - see 'man ps' for details
* @param format
* @return char * processes
*/
char *
dbe_get_processes (const char *format)
{
StringBuilder sb;
if (!strcmp (format, NTXT ("/bin/ps -ef")))
{
char buf[BUFSIZ];
FILE *ptr = popen (format, "r");
if (ptr != NULL)
{
while (fgets (buf, BUFSIZ, ptr) != NULL)
sb.append (buf);
pclose (ptr);
}
}
return sb.toString ();
}
/**
* Creates the directory named by the specified path name, including any
* necessary but nonexistent parent directories.
* Uses system utility "/bin/mkdir -p"
* Temporary limitation: path name should not contain spaces.
* Returns message from "/bin/mkdir -p"
* @param pathname
* @return result
*/
char *
dbe_create_directories (const char *pathname)
{
StringBuilder sb;
char *makedir = dbe_sprintf (NTXT ("/bin/mkdir -p %s 2>&1"), pathname);
char out[BUFSIZ];
FILE *ptr = popen (makedir, "r");
if (ptr != NULL)
{
while (fgets (out, BUFSIZ, ptr) != NULL)
sb.append (out);
pclose (ptr);
}
free (makedir);
DIR *dir = opendir (pathname);
if (dir != NULL)
{
closedir (dir);
return NULL; // success
}
else
sb.append (NTXT ("\nError: Cannot open directory\n")); // DEBUG
return sb.toString (); // error
}
/**
* Deletes the file or the directory named by the specified path name.
* If this pathname denotes a directory, then the directory must be empty in order to be deleted.
* Uses system utility "/bin/rm" or "/bin/rmdir"
* Temporary limitation: path name should not contain spaces.
* Returns error message from system utility
* @param pathname
* @return result
*/
char *
dbe_delete_file (const char *pathname)
{
StringBuilder sb;
char *cmd = NULL;
struct stat64 sbuf;
sbuf.st_mode = 0;
int st = dbe_stat (pathname, &sbuf);
if (st == 0)
{ // Exists
if (S_ISDIR (sbuf.st_mode) != 0) // Directory
cmd = dbe_sprintf (NTXT ("/bin/rmdir %s 2>&1"), pathname);
else if (S_ISREG (sbuf.st_mode) != 0) // Regular file
cmd = dbe_sprintf (NTXT ("/bin/rm %s 2>&1"), pathname);
}
else
return NULL; // Nothing to remove
if (cmd != NULL)
{
char out[BUFSIZ];
FILE *ptr = popen (cmd, "r");
if (ptr != NULL)
{
while (fgets (out, BUFSIZ, ptr) != NULL)
sb.append (out);
pclose (ptr);
}
free (cmd);
}
else
sb.sprintf (NTXT ("Error: cannot remove %s - not a regular file and not a directory\n"), pathname);
return sb.toString ();
}
char *
dbe_xml2str (const char *s)
{
if (s == NULL)
return NULL;
StringBuilder sb;
while (*s)
{
if (*s == '&')
{
if (strncmp (s, NTXT ("&nbsp;"), 6) == 0)
{
sb.append (' ');
s += 6;
continue;
}
else if (strncmp (s, NTXT ("&quot;"), 6) == 0)
{
sb.append ('"');
s += 6;
continue;
}
else if (strncmp (s, NTXT ("&amp;"), 5) == 0)
{
sb.append ('&');
s += 5;
continue;
}
else if (strncmp (s, NTXT ("&lt;"), 4) == 0)
{
sb.append ('<');
s += 4;
continue;
}
else if (strncmp (s, NTXT ("&gt;"), 4) == 0)
{
sb.append ('>');
s += 4;
continue;
}
}
sb.append (*s);
s++;
}
return sb.toString ();
}
void
swapByteOrder (void *p, size_t sz)
{
if (sz == 8)
{
uint64_t *pv = (uint64_t *) p;
uint64_t v = *pv;
v = ((v & 0x00000000FF000000) << 8) | ((v >> 8) & 0x00000000FF000000) |
((v & 0x0000000000FF0000) << 24) | ((v >> 24) & 0x0000000000FF0000) |
((v & 0x000000000000FF00) << 40) | ((v >> 40) & 0x000000000000FF00) |
(v >> 56) | (v << 56);
*pv = v;
}
else if (sz == 4)
{
uint32_t *pv = (uint32_t *) p;
uint32_t v = *pv;
v = (v >> 24) | (v << 24) | ((v & 0x0000FF00) << 8) | ((v >> 8) & 0x0000FF00);
*pv = v;
}
else if (sz == 2)
{
uint16_t *pv = (uint16_t *) p;
uint16_t v = *pv;
v = (v >> 8) | (v << 8);
*pv = v;
}
}
void
destroy (void *vec)
{
if (vec == NULL)
return;
Vector<void*> *array = (Vector<void*>*)vec;
switch (array->type ())
{
case VEC_STRING:
((Vector<char *>*)array)->destroy ();
break;
case VEC_VOIDARR:
case VEC_STRINGARR:
case VEC_INTARR:
case VEC_BOOLARR:
case VEC_LLONGARR:
case VEC_DOUBLEARR:
for (long i = 0; i < array->size (); i++)
destroy (array->fetch (i));
break;
case VEC_INTEGER:
case VEC_CHAR:
case VEC_BOOL:
case VEC_DOUBLE:
case VEC_LLONG:
default:
break;
}
delete array;
}
int64_t
read_from_file (int fd, void *buffer, int64_t nbyte)
{
int64_t cnt = 0;
char *buf = (char *) buffer;
while (nbyte > 0)
{ // Sometimes system cannot read 'nbyte'
ssize_t n = read (fd, (void *) (buf + cnt), (size_t) nbyte);
if (n <= 0)
break;
nbyte -= n;
cnt += n;
}
return cnt;
}
/**
* Create symbolic link to the path
* @param path - path with spaces
* @param dir - directory where the link should be created
* @return symbolic link
*/
char *
dbe_create_symlink_to_path (const char *path, const char *dir)
{
char *symbolic_link = NULL;
if (NULL == path || NULL == dir)
return NULL;
int res = mkdir (dir, 0777);
if (res != 0 && dbe_stat (dir, NULL) != 0)
return NULL; // Cannot create directory
long len = dbe_sstrlen (path);
if (len <= 4)
return NULL; // Unknown situation
if (strcmp ((path + len - 4), "/bin") != 0) // Unknown situation
return NULL;
int max = 99; // Just an arbitrary number
for (int i = 1; i <= max; i++)
{
// Try to create symbolic link
char *d = dbe_sprintf ("%s/%d", dir, i);
if (NULL == d)
return NULL;
res = mkdir (d, 0777);
symbolic_link = dbe_sprintf ("%s/%s", d, "bin");
free (d);
if (NULL == symbolic_link) // Not enough memory
return NULL;
res = symlink (path, symbolic_link);
if (res == 0) // Link is created - use it.
break;
// Check if such link already exists
int e = errno;
char buf[MAXPATHLEN + 1];
memset (buf, 0, MAXPATHLEN + 1);
ssize_t n = readlink (symbolic_link, buf, MAXPATHLEN);
if (n == len && strcmp (path, buf) == 0) // Link is correct - use it.
break;
if (i == max)
{ // report the error
fprintf (stderr, GTXT ("Error: symlink(%s, %s) returned error: %d\n"), path, symbolic_link, res);
fprintf (stderr, GTXT ("Error: errno=%d (%s)\n"), e, strerror (e));
fflush (stderr);
}
free (symbolic_link);
symbolic_link = NULL;
}
return symbolic_link;
}
// Compute checksum for specified file.
// This code is from usr/src/cmd/cksum.c, adapted for us
// crcposix -- compute posix.2 compatable 32 bit CRC
//
// The POSIX.2 (draft 10) CRC algorithm.
// This is a 32 bit CRC with polynomial
// x**32 + x**26 + x**23 + x**22 + x**16 + x**12 + x**11 + x**10 +
// x**8 + x**7 + x**5 + x**4 + x**2 + x**1 + x**0
//
// layout is from the POSIX.2 Rationale
static uint32_t crctab_posix[256] = {
0x00000000L,
0x04C11DB7L, 0x09823B6EL, 0x0D4326D9L, 0x130476DCL, 0x17C56B6BL,
0x1A864DB2L, 0x1E475005L, 0x2608EDB8L, 0x22C9F00FL, 0x2F8AD6D6L,
0x2B4BCB61L, 0x350C9B64L, 0x31CD86D3L, 0x3C8EA00AL, 0x384FBDBDL,
0x4C11DB70L, 0x48D0C6C7L, 0x4593E01EL, 0x4152FDA9L, 0x5F15ADACL,
0x5BD4B01BL, 0x569796C2L, 0x52568B75L, 0x6A1936C8L, 0x6ED82B7FL,
0x639B0DA6L, 0x675A1011L, 0x791D4014L, 0x7DDC5DA3L, 0x709F7B7AL,
0x745E66CDL, 0x9823B6E0L, 0x9CE2AB57L, 0x91A18D8EL, 0x95609039L,
0x8B27C03CL, 0x8FE6DD8BL, 0x82A5FB52L, 0x8664E6E5L, 0xBE2B5B58L,
0xBAEA46EFL, 0xB7A96036L, 0xB3687D81L, 0xAD2F2D84L, 0xA9EE3033L,
0xA4AD16EAL, 0xA06C0B5DL, 0xD4326D90L, 0xD0F37027L, 0xDDB056FEL,
0xD9714B49L, 0xC7361B4CL, 0xC3F706FBL, 0xCEB42022L, 0xCA753D95L,
0xF23A8028L, 0xF6FB9D9FL, 0xFBB8BB46L, 0xFF79A6F1L, 0xE13EF6F4L,
0xE5FFEB43L, 0xE8BCCD9AL, 0xEC7DD02DL, 0x34867077L, 0x30476DC0L,
0x3D044B19L, 0x39C556AEL, 0x278206ABL, 0x23431B1CL, 0x2E003DC5L,
0x2AC12072L, 0x128E9DCFL, 0x164F8078L, 0x1B0CA6A1L, 0x1FCDBB16L,
0x018AEB13L, 0x054BF6A4L, 0x0808D07DL, 0x0CC9CDCAL, 0x7897AB07L,
0x7C56B6B0L, 0x71159069L, 0x75D48DDEL, 0x6B93DDDBL, 0x6F52C06CL,
0x6211E6B5L, 0x66D0FB02L, 0x5E9F46BFL, 0x5A5E5B08L, 0x571D7DD1L,
0x53DC6066L, 0x4D9B3063L, 0x495A2DD4L, 0x44190B0DL, 0x40D816BAL,
0xACA5C697L, 0xA864DB20L, 0xA527FDF9L, 0xA1E6E04EL, 0xBFA1B04BL,
0xBB60ADFCL, 0xB6238B25L, 0xB2E29692L, 0x8AAD2B2FL, 0x8E6C3698L,
0x832F1041L, 0x87EE0DF6L, 0x99A95DF3L, 0x9D684044L, 0x902B669DL,
0x94EA7B2AL, 0xE0B41DE7L, 0xE4750050L, 0xE9362689L, 0xEDF73B3EL,
0xF3B06B3BL, 0xF771768CL, 0xFA325055L, 0xFEF34DE2L, 0xC6BCF05FL,
0xC27DEDE8L, 0xCF3ECB31L, 0xCBFFD686L, 0xD5B88683L, 0xD1799B34L,
0xDC3ABDEDL, 0xD8FBA05AL, 0x690CE0EEL, 0x6DCDFD59L, 0x608EDB80L,
0x644FC637L, 0x7A089632L, 0x7EC98B85L, 0x738AAD5CL, 0x774BB0EBL,
0x4F040D56L, 0x4BC510E1L, 0x46863638L, 0x42472B8FL, 0x5C007B8AL,
0x58C1663DL, 0x558240E4L, 0x51435D53L, 0x251D3B9EL, 0x21DC2629L,
0x2C9F00F0L, 0x285E1D47L, 0x36194D42L, 0x32D850F5L, 0x3F9B762CL,
0x3B5A6B9BL, 0x0315D626L, 0x07D4CB91L, 0x0A97ED48L, 0x0E56F0FFL,
0x1011A0FAL, 0x14D0BD4DL, 0x19939B94L, 0x1D528623L, 0xF12F560EL,
0xF5EE4BB9L, 0xF8AD6D60L, 0xFC6C70D7L, 0xE22B20D2L, 0xE6EA3D65L,
0xEBA91BBCL, 0xEF68060BL, 0xD727BBB6L, 0xD3E6A601L, 0xDEA580D8L,
0xDA649D6FL, 0xC423CD6AL, 0xC0E2D0DDL, 0xCDA1F604L, 0xC960EBB3L,
0xBD3E8D7EL, 0xB9FF90C9L, 0xB4BCB610L, 0xB07DABA7L, 0xAE3AFBA2L,
0xAAFBE615L, 0xA7B8C0CCL, 0xA379DD7BL, 0x9B3660C6L, 0x9FF77D71L,
0x92B45BA8L, 0x9675461FL, 0x8832161AL, 0x8CF30BADL, 0x81B02D74L,
0x857130C3L, 0x5D8A9099L, 0x594B8D2EL, 0x5408ABF7L, 0x50C9B640L,
0x4E8EE645L, 0x4A4FFBF2L, 0x470CDD2BL, 0x43CDC09CL, 0x7B827D21L,
0x7F436096L, 0x7200464FL, 0x76C15BF8L, 0x68860BFDL, 0x6C47164AL,
0x61043093L, 0x65C52D24L, 0x119B4BE9L, 0x155A565EL, 0x18197087L,
0x1CD86D30L, 0x029F3D35L, 0x065E2082L, 0x0B1D065BL, 0x0FDC1BECL,
0x3793A651L, 0x3352BBE6L, 0x3E119D3FL, 0x3AD08088L, 0x2497D08DL,
0x2056CD3AL, 0x2D15EBE3L, 0x29D4F654L, 0xC5A92679L, 0xC1683BCEL,
0xCC2B1D17L, 0xC8EA00A0L, 0xD6AD50A5L, 0xD26C4D12L, 0xDF2F6BCBL,
0xDBEE767CL, 0xE3A1CBC1L, 0xE760D676L, 0xEA23F0AFL, 0xEEE2ED18L,
0xF0A5BD1DL, 0xF464A0AAL, 0xF9278673L, 0xFDE69BC4L, 0x89B8FD09L,
0x8D79E0BEL, 0x803AC667L, 0x84FBDBD0L, 0x9ABC8BD5L, 0x9E7D9662L,
0x933EB0BBL, 0x97FFAD0CL, 0xAFB010B1L, 0xAB710D06L, 0xA6322BDFL,
0xA2F33668L, 0xBCB4666DL, 0xB8757BDAL, 0xB5365D03L, 0xB1F740B4L
};
static void
m_crcposix (uint32_t *crcp, unsigned char *bp, uint32_t n)
{
while (n-- > 0)
*crcp = (*crcp << 8) ^ crctab_posix[(unsigned char) ((*crcp >> 24)^*bp++)];
}
// Do CRC-POSIX function by calling a library entry point that has a
// slightly different calling sequence.
static uint32_t
docrcposix (uint32_t crcval, unsigned char *bp, uint32_t n)
{
m_crcposix (&crcval, bp, n);
return (crcval);
}
// Sum algorithms require various kinds of post-processing.
// The 'S' and 'R' variables are from the POSIX.2 (Draft 8?) description
// of the "sum" utility.
static uint32_t
postprocess (uint32_t S, long long n)
{
// POSIX tacks on significant bytes of the length so that
// different length sequences of '\0' have different sums;
// then it complements sum.
unsigned char char_n[sizeof (n)];
uint32_t i;
for (i = 0; n != 0; n >>= 8, ++i)
char_n[i] = (unsigned char) (n & 0xFF);
return (~docrcposix (S, char_n, i));
}
uint32_t
get_cksum (const char * pathname, char ** errmsg)
{
int fd = open (pathname, O_RDONLY);
if (fd < 0)
{
if (errmsg)
*errmsg = dbe_sprintf (GTXT ("*** Warning: Error opening file for reading: %s"), pathname);
return 0; // error
}
uint32_t crcval = 0;
long long bytes = 0;
int64_t n;
unsigned char buf[4096];
while ((n = read_from_file (fd, (char *) buf, sizeof (buf))) > 0)
{
bytes += n;
crcval = docrcposix (crcval, buf, n);
}
close (fd);
crcval = postprocess (crcval, bytes);
return crcval;
}
Reference in New Issue View Git Blame Copy Permalink