static int pgfuse_open( const char *path, struct fuse_file_info *fi )
{
PgFuseData *data = (PgFuseData *)fuse_get_context( )->private_data;
PgMeta meta;
int64_t id;
int64_t res;
PGconn *conn;
if( data->verbose ) {
char *s = flags_to_string( fi->flags );
syslog( LOG_INFO, "Open '%s' on '%s' with flags '%s', thread #%u",
path, data->mountpoint, s, THREAD_ID );
if( *s != '<' ) free( s );
}
ACQUIRE( conn );
PSQL_BEGIN( conn );
id = psql_read_meta_from_path( conn, path, &meta );
if( id < 0 ) {
PSQL_ROLLBACK( conn ); RELEASE( conn );
return id;
}
if( data->verbose ) {
syslog( LOG_DEBUG, "Id for file '%s' to open is %"PRIi64", thread #%u",
path, id, THREAD_ID );
}
if( S_ISDIR( meta.mode ) ) {
PSQL_ROLLBACK( conn ); RELEASE( conn );
return -EISDIR;
}
if( data->read_only ) {
if( ( fi->flags & O_ACCMODE ) != O_RDONLY ) {
PSQL_ROLLBACK( conn ); RELEASE( conn );
return -EROFS;
}
}
if( !data->noatime ) {
meta.atime = now( );
}
res = psql_write_meta( conn, id, path, meta );
if( res < 0 ) {
PSQL_ROLLBACK( conn ); RELEASE( conn );
return res;
}
fi->fh = id;
PSQL_COMMIT( conn ); RELEASE( conn );
return 0;
}
/* flush stacked and waiting cmodes */
static void flush_cmode(struct modedata_ *md)
{
char buf[BUFSIZE];
int len = 0;
char lastc = 0;
if (!md->binmodes_on && !md->binmodes_off && !*md->opmodes)
{
memset(md, 0, sizeof(*md));
md->last_add = -1;
return;
}
if (md->binmodes_off)
{
len += snprintf(buf + len, sizeof(buf) - len, "-%s",
flags_to_string(md->binmodes_off));
lastc = '-';
}
if (md->binmodes_on)
{
len += snprintf(buf + len, sizeof(buf) - len, "+%s",
flags_to_string(md->binmodes_on));
lastc = '+';
}
if (*md->opmodes)
{
if (*md->opmodes == lastc)
memmove(md->opmodes, md->opmodes + 1, strlen(md->opmodes + 1) + 1);
len += snprintf(buf + len, sizeof(buf) - len, "%s", md->opmodes);
}
if (md->paramslen)
snprintf(buf + len, sizeof(buf) - len, " %s", md->params);
sts(":%s MODE %s %s", md->sender, md->channel, buf);
memset(md, 0, sizeof(*md));
md->last_add = -1;
}
static void
shownode(NODE *n, int f, char const *path)
{
struct group *gr;
struct passwd *pw;
printf("%s%s %s", path, n->name, ftype(n->type));
if (f & F_CKSUM)
printf(" cksum=%lu", n->cksum);
if (f & F_GID)
printf(" gid=%d", n->st_gid);
if (f & F_GNAME) {
gr = getgrgid(n->st_gid);
if (gr == NULL)
printf(" gid=%d", n->st_gid);
else
printf(" gname=%s", gr->gr_name);
}
if (f & F_MODE)
printf(" mode=%o", n->st_mode);
if (f & F_NLINK)
printf(" nlink=%d", (int)n->st_nlink);
if (f & F_SLINK)
printf(" link=%s", n->slink);
if (f & F_SIZE)
printf(" size=%jd", (intmax_t)n->st_size);
if (f & F_TIME)
printf(" time=%ld.%09ld", (long)n->st_mtimespec.tv_sec, n->st_mtimespec.tv_nsec);
if (f & F_UID)
printf(" uid=%d", n->st_uid);
if (f & F_UNAME) {
pw = getpwuid(n->st_uid);
if (pw == NULL)
printf(" uid=%d", n->st_uid);
else
printf(" uname=%s", pw->pw_name);
}
if (f & F_MD5)
printf(" md5digest=%s", n->md5digest);
if (f & F_SHA1)
printf(" sha1digest=%s", n->sha1digest);
if (f & F_RMD160)
printf(" rmd160digest=%s", n->rmd160digest);
if (f & F_SHA256)
printf(" sha256digest=%s", n->sha256digest);
if (f & F_SHA384)
printf(" sha384digest=%s", n->sha384digest);
if (f & F_SHA512)
printf(" sha512digest=%s", n->sha512digest);
if (f & F_FLAGS)
printf(" flags=%s", flags_to_string(n->st_flags));
printf("\n");
}
check(char *path, char *name, struct stat *sp)
#endif
{
int ch, first;
#ifdef __GNO__
static
#endif
char modep[15], flagsp[128];
/* Check -i first. */
if (iflag)
(void)fprintf(stderr, "remove %s? ", path);
else {
/*
* If it's not a symbolic link and it's unwritable and we're
* talking to a terminal, ask. Symbolic links are excluded
* because their permissions are meaningless. Check stdin_ok
* first because we may not have stat'ed the file.
*/
#ifndef __GNO__
if (!stdin_ok || S_ISLNK(sp->st_mode) ||
!access(name, W_OK) &&
!(sp->st_flags & (SF_APPEND|SF_IMMUTABLE)) &&
(!(sp->st_flags & (UF_APPEND|UF_IMMUTABLE)) || !uid))
return (1);
strmode(sp->st_mode, modep);
strcpy(flagsp, flags_to_string(sp->st_flags, NULL));
if (*flagsp)
strcat(flagsp, " ");
(void)fprintf(stderr, "override %s%s%s/%s %sfor %s? ",
modep + 1, modep[9] == ' ' ? "" : " ",
user_from_uid(sp->st_uid, 0),
group_from_gid(sp->st_gid, 0),
*flagsp ? flagsp : "",
path);
#else
if (!stdin_ok || !access(name,W_OK))
return (1);
(void)fprintf(stderr, "override protection for %s? ",
path);
#endif
}
(void)fflush(stderr);
first = ch = getchar();
while (ch != '\n' && ch != EOF)
ch = getchar();
return (first == 'y' || first == 'Y');
}
static int
statd(FTS *t, FTSENT *parent, uid_t *puid, gid_t *pgid, mode_t *pmode, u_long *pflags)
{
FTSENT *p;
gid_t sgid;
uid_t suid;
mode_t smode;
u_long sflags;
struct group *gr;
struct passwd *pw;
gid_t savegid = *pgid;
uid_t saveuid = *puid;
mode_t savemode = *pmode;
u_long saveflags = *pflags;
u_short maxgid, maxuid, maxmode, maxflags;
u_short g[MAXGID], u[MAXUID], m[MAXMODE], f[MAXFLAGS];
char *fflags;
static int first = 1;
if ((p = fts_children(t, 0)) == NULL) {
if (errno)
err(1, "%s", RP(parent));
return (1);
}
bzero(g, sizeof(g));
bzero(u, sizeof(u));
bzero(m, sizeof(m));
bzero(f, sizeof(f));
maxuid = maxgid = maxmode = maxflags = 0;
for (; p; p = p->fts_link) {
if (!dflag || (dflag && S_ISDIR(p->fts_statp->st_mode))) {
smode = p->fts_statp->st_mode & MBITS;
if (smode < MAXMODE && ++m[smode] > maxmode) {
savemode = smode;
maxmode = m[smode];
}
sgid = p->fts_statp->st_gid;
if (sgid < MAXGID && ++g[sgid] > maxgid) {
savegid = sgid;
maxgid = g[sgid];
}
suid = p->fts_statp->st_uid;
if (suid < MAXUID && ++u[suid] > maxuid) {
saveuid = suid;
maxuid = u[suid];
}
/*
* XXX
* note that the below will break when file flags
* are extended beyond the first 4 bytes of each
* half word of the flags
*/
#define FLAGS2IDX(f) ((f & 0xf) | ((f >> 12) & 0xf0))
sflags = p->fts_statp->st_flags;
if (FLAGS2IDX(sflags) < MAXFLAGS &&
++f[FLAGS2IDX(sflags)] > maxflags) {
saveflags = sflags;
maxflags = f[FLAGS2IDX(sflags)];
}
}
}
/*
* If the /set record is the same as the last one we do not need to output
* a new one. So first we check to see if anything changed. Note that we
* always output a /set record for the first directory.
*/
if ((((keys & F_UNAME) | (keys & F_UID)) && (*puid != saveuid)) ||
(((keys & F_GNAME) | (keys & F_GID)) && (*pgid != savegid)) ||
((keys & F_MODE) && (*pmode != savemode)) ||
((keys & F_FLAGS) && (*pflags != saveflags)) ||
(first)) {
first = 0;
if (dflag)
(void)printf("/set type=dir");
else
(void)printf("/set type=file");
if (keys & F_UNAME) {
pw = getpwuid(saveuid);
if (pw != NULL)
(void)printf(" uname=%s", pw->pw_name);
else if (wflag)
warnx( "Could not get uname for uid=%u", saveuid);
else
errx(1, "Could not get uname for uid=%u", saveuid);
}
if (keys & F_UID)
(void)printf(" uid=%lu", (u_long)saveuid);
if (keys & F_GNAME) {
gr = getgrgid(savegid);
if (gr != NULL)
(void)printf(" gname=%s", gr->gr_name);
else if (wflag)
warnx("Could not get gname for gid=%u", savegid);
else
errx(1, "Could not get gname for gid=%u", savegid);
}
if (keys & F_GID)
(void)printf(" gid=%lu", (u_long)savegid);
if (keys & F_MODE)
(void)printf(" mode=%#o", savemode);
if (keys & F_NLINK)
(void)printf(" nlink=1");
if (keys & F_FLAGS) {
fflags = flags_to_string(saveflags);
(void)printf(" flags=%s", fflags);
free(fflags);
}
(void)printf("\n");
*puid = saveuid;
*pgid = savegid;
*pmode = savemode;
*pflags = saveflags;
}
return (0);
}
static void
statf(int indent, FTSENT *p)
{
struct group *gr;
struct passwd *pw;
uint32_t val;
off_t len;
int fd, offset;
char *fflags;
char *escaped_name;
escaped_name = calloc(1, p->fts_namelen * 4 + 1);
if (escaped_name == NULL)
errx(1, "statf(): calloc() failed");
strvis(escaped_name, p->fts_name, VIS_WHITE | VIS_OCTAL | VIS_GLOB);
if (iflag || S_ISDIR(p->fts_statp->st_mode))
offset = printf("%*s%s", indent, "", escaped_name);
else
offset = printf("%*s %s", indent, "", escaped_name);
free(escaped_name);
if (offset > (INDENTNAMELEN + indent))
offset = MAXLINELEN;
else
offset += printf("%*s", (INDENTNAMELEN + indent) - offset, "");
if (!S_ISREG(p->fts_statp->st_mode) && !dflag)
output(indent, &offset, "type=%s", inotype(p->fts_statp->st_mode));
if (p->fts_statp->st_uid != uid) {
if (keys & F_UNAME) {
pw = getpwuid(p->fts_statp->st_uid);
if (pw != NULL)
output(indent, &offset, "uname=%s", pw->pw_name);
else if (wflag)
warnx("Could not get uname for uid=%u",
p->fts_statp->st_uid);
else
errx(1,
"Could not get uname for uid=%u",
p->fts_statp->st_uid);
}
if (keys & F_UID)
output(indent, &offset, "uid=%u", p->fts_statp->st_uid);
}
if (p->fts_statp->st_gid != gid) {
if (keys & F_GNAME) {
gr = getgrgid(p->fts_statp->st_gid);
if (gr != NULL)
output(indent, &offset, "gname=%s", gr->gr_name);
else if (wflag)
warnx("Could not get gname for gid=%u",
p->fts_statp->st_gid);
else
errx(1,
"Could not get gname for gid=%u",
p->fts_statp->st_gid);
}
if (keys & F_GID)
output(indent, &offset, "gid=%u", p->fts_statp->st_gid);
}
if (keys & F_MODE && (p->fts_statp->st_mode & MBITS) != mode)
output(indent, &offset, "mode=%#o", p->fts_statp->st_mode & MBITS);
if (keys & F_NLINK && p->fts_statp->st_nlink != 1)
output(indent, &offset, "nlink=%u", p->fts_statp->st_nlink);
if (keys & F_SIZE)
output(indent, &offset, "size=%jd",
(intmax_t)p->fts_statp->st_size);
if (keys & F_TIME)
output(indent, &offset, "time=%ld.%ld",
(long)p->fts_statp->st_mtimespec.tv_sec,
p->fts_statp->st_mtimespec.tv_nsec);
if (keys & F_CKSUM && S_ISREG(p->fts_statp->st_mode)) {
if ((fd = open(p->fts_accpath, O_RDONLY, 0)) < 0 ||
crc(fd, &val, &len))
err(1, "%s", p->fts_accpath);
(void)close(fd);
output(indent, &offset, "cksum=%lu", (unsigned long)val);
}
#ifdef ENABLE_MD5
if (keys & F_MD5 && S_ISREG(p->fts_statp->st_mode)) {
char *digest, buf[33];
digest = MD5File(p->fts_accpath, buf);
if (!digest)
err(1, "%s", p->fts_accpath);
output(indent, &offset, "md5digest=%s", digest);
}
#endif /* ENABLE_MD5 */
#ifdef ENABLE_SHA1
if (keys & F_SHA1 && S_ISREG(p->fts_statp->st_mode)) {
char *digest, buf[41];
digest = SHA1_File(p->fts_accpath, buf);
if (!digest)
err(1, "%s", p->fts_accpath);
output(indent, &offset, "sha1digest=%s", digest);
}
#endif /* ENABLE_SHA1 */
#ifdef ENABLE_RMD160
if (keys & F_RMD160 && S_ISREG(p->fts_statp->st_mode)) {
char *digest, buf[41];
digest = RIPEMD160_File(p->fts_accpath, buf);
if (!digest)
err(1, "%s", p->fts_accpath);
output(indent, &offset, "ripemd160digest=%s", digest);
}
#endif /* ENABLE_RMD160 */
#ifdef ENABLE_SHA256
if (keys & F_SHA256 && S_ISREG(p->fts_statp->st_mode)) {
char *digest, buf[65];
digest = SHA256_File(p->fts_accpath, buf);
if (!digest)
err(1, "%s", p->fts_accpath);
output(indent, &offset, "sha256digest=%s", digest);
}
#endif /* ENABLE_SHA256 */
if (keys & F_SLINK &&
(p->fts_info == FTS_SL || p->fts_info == FTS_SLNONE)) {
char visbuf[MAXPATHLEN * 4];
char *s = rlink(p->fts_accpath);
strvis(visbuf, s, VIS_WHITE | VIS_OCTAL);
output(indent, &offset, "link=%s", visbuf);
}
if (keys & F_FLAGS && p->fts_statp->st_flags != flags) {
fflags = flags_to_string(p->fts_statp->st_flags);
output(indent, &offset, "flags=%s", fflags);
free(fflags);
}
(void)putchar('\n');
}
int
main ()
{
time_t now;
int i;
int errors = 0, count = 0;
time (&now);
srandom ((unsigned int) now + getpid ());
grow_layer_list (0);
for (i = 0; i < 16; i++)
{
int j;
char *p;
if (i != 1 && i != 4 && i != 5 && i != 9)
set_layer_list (i, 1);
else
set_layer_list (i, 0);
p = print_layer_list ();
printf ("%2d : %20s =", i, p);
parse_layer_list (p + 1, 0);
for (j = 0; j < num_layers; j++)
printf (" %d", layers[j]);
printf ("\n");
}
while (count < 1000000)
{
FlagHolder fh;
char *str;
FlagType new_flags;
int i;
int otype;
otype = ALL_TYPES;
fh.Flags = empty_flags;
for (i = 0; i < ENTRIES (object_flagbits); i++)
{
if (TEST_FLAG (object_flagbits[i].mask, &fh))
continue;
if ((otype & object_flagbits[i].object_types) == 0)
continue;
if ((random () & 4) == 0)
continue;
otype &= object_flagbits[i].object_types;
SET_FLAG (object_flagbits[i].mask, &fh);
}
if (otype & PIN_TYPES)
for (i = 0; i < MAX_LAYER; i++)
if (random () & 4)
ASSIGN_THERM (i, 3, &fh);
str = flags_to_string (fh.Flags, otype);
new_flags = string_to_flags (str, 0);
count++;
if (FLAGS_EQUAL (fh.Flags, new_flags))
continue;
dump_flag (&fh.Flags);
printf (" ");
dump_flag (&new_flags);
printf ("\n");
if (++errors == 5)
exit (1);
}
while (count < 1000000)
{
FlagHolder fh;
char *str;
FlagType new_flags;
int i;
int otype;
otype = ALL_TYPES;
fh.Flags = empty_flags;
for (i = 0; i < ENTRIES (pcb_flagbits); i++)
{
if (TEST_FLAG (pcb_flagbits[i].mask, &fh))
continue;
if ((random () & 4) == 0)
continue;
otype &= pcb_flagbits[i].object_types;
SET_FLAG (pcb_flagbits[i].mask, &fh);
}
str = pcbflags_to_string (fh.Flags);
new_flags = string_to_pcbflags (str, 0);
count++;
if (FLAGS_EQUAL (fh.Flags, new_flags))
continue;
dump_flag (&fh.Flags);
printf (" ");
dump_flag (&new_flags);
printf ("\n");
if (++errors == 5)
exit (1);
}
printf ("%d out of %d failed\n", errors, count);
return errors;
}
static void
print_element_properties_info (GstElement * element)
{
GParamSpec **property_specs;
guint num_properties, i;
gboolean readable;
gboolean first_flag;
property_specs = g_object_class_list_properties
(G_OBJECT_GET_CLASS (element), &num_properties);
n_print ("\n");
n_print ("Element Properties:\n");
for (i = 0; i < num_properties; i++) {
GValue value = { 0, };
GParamSpec *param = property_specs[i];
readable = FALSE;
g_value_init (&value, param->value_type);
n_print (" %-20s: %s\n", g_param_spec_get_name (param),
g_param_spec_get_blurb (param));
first_flag = TRUE;
n_print ("%-23.23s flags: ", "");
if (param->flags & G_PARAM_READABLE) {
g_object_get_property (G_OBJECT (element), param->name, &value);
readable = TRUE;
g_print ("%s%s", (first_flag) ? "" : ", ", _("readable"));
first_flag = FALSE;
} else {
/* if we can't read the property value, assume it's set to the default
* (which might not be entirely true for sub-classes, but that's an
* unlikely corner-case anyway) */
g_param_value_set_default (param, &value);
}
if (param->flags & G_PARAM_WRITABLE) {
g_print ("%s%s", (first_flag) ? "" : ", ", _("writable"));
first_flag = FALSE;
}
if (param->flags & G_PARAM_DEPRECATED) {
g_print ("%s%s", (first_flag) ? "" : ", ", _("deprecated"));
first_flag = FALSE;
}
if (param->flags & GST_PARAM_CONTROLLABLE) {
g_print (", %s", _("controllable"));
first_flag = FALSE;
}
if (param->flags & GST_PARAM_MUTABLE_PLAYING) {
g_print (", %s", _("changeable in NULL, READY, PAUSED or PLAYING state"));
} else if (param->flags & GST_PARAM_MUTABLE_PAUSED) {
g_print (", %s", _("changeable only in NULL, READY or PAUSED state"));
} else if (param->flags & GST_PARAM_MUTABLE_READY) {
g_print (", %s", _("changeable only in NULL or READY state"));
}
if (param->flags & ~KNOWN_PARAM_FLAGS) {
g_print ("%s0x%0x", (first_flag) ? "" : ", ",
param->flags & ~KNOWN_PARAM_FLAGS);
}
n_print ("\n");
switch (G_VALUE_TYPE (&value)) {
case G_TYPE_STRING:
{
const char *string_val = g_value_get_string (&value);
n_print ("%-23.23s String. ", "");
if (string_val == NULL)
g_print ("Default: null");
else
g_print ("Default: \"%s\"", string_val);
break;
}
case G_TYPE_BOOLEAN:
{
gboolean bool_val = g_value_get_boolean (&value);
n_print ("%-23.23s Boolean. ", "");
g_print ("Default: %s", bool_val ? "true" : "false");
break;
}
case G_TYPE_ULONG:
{
GParamSpecULong *pulong = G_PARAM_SPEC_ULONG (param);
n_print ("%-23.23s Unsigned Long. ", "");
g_print ("Range: %lu - %lu Default: %lu ",
pulong->minimum, pulong->maximum, g_value_get_ulong (&value));
GST_ERROR ("%s: property '%s' of type ulong: consider changing to "
"uint/uint64", GST_OBJECT_NAME (element),
g_param_spec_get_name (param));
break;
}
case G_TYPE_LONG:
{
GParamSpecLong *plong = G_PARAM_SPEC_LONG (param);
n_print ("%-23.23s Long. ", "");
g_print ("Range: %ld - %ld Default: %ld ",
plong->minimum, plong->maximum, g_value_get_long (&value));
GST_ERROR ("%s: property '%s' of type long: consider changing to "
"int/int64", GST_OBJECT_NAME (element),
g_param_spec_get_name (param));
break;
}
case G_TYPE_UINT:
{
GParamSpecUInt *puint = G_PARAM_SPEC_UINT (param);
n_print ("%-23.23s Unsigned Integer. ", "");
g_print ("Range: %u - %u Default: %u ",
puint->minimum, puint->maximum, g_value_get_uint (&value));
break;
}
case G_TYPE_INT:
{
GParamSpecInt *pint = G_PARAM_SPEC_INT (param);
n_print ("%-23.23s Integer. ", "");
g_print ("Range: %d - %d Default: %d ",
pint->minimum, pint->maximum, g_value_get_int (&value));
break;
}
case G_TYPE_UINT64:
{
GParamSpecUInt64 *puint64 = G_PARAM_SPEC_UINT64 (param);
n_print ("%-23.23s Unsigned Integer64. ", "");
g_print ("Range: %" G_GUINT64_FORMAT " - %" G_GUINT64_FORMAT
" Default: %" G_GUINT64_FORMAT " ",
puint64->minimum, puint64->maximum, g_value_get_uint64 (&value));
break;
}
case G_TYPE_INT64:
{
GParamSpecInt64 *pint64 = G_PARAM_SPEC_INT64 (param);
n_print ("%-23.23s Integer64. ", "");
g_print ("Range: %" G_GINT64_FORMAT " - %" G_GINT64_FORMAT
" Default: %" G_GINT64_FORMAT " ",
pint64->minimum, pint64->maximum, g_value_get_int64 (&value));
break;
}
case G_TYPE_FLOAT:
{
GParamSpecFloat *pfloat = G_PARAM_SPEC_FLOAT (param);
n_print ("%-23.23s Float. ", "");
g_print ("Range: %15.7g - %15.7g Default: %15.7g ",
pfloat->minimum, pfloat->maximum, g_value_get_float (&value));
break;
}
case G_TYPE_DOUBLE:
{
GParamSpecDouble *pdouble = G_PARAM_SPEC_DOUBLE (param);
n_print ("%-23.23s Double. ", "");
g_print ("Range: %15.7g - %15.7g Default: %15.7g ",
pdouble->minimum, pdouble->maximum, g_value_get_double (&value));
break;
}
case G_TYPE_CHAR:
case G_TYPE_UCHAR:
GST_ERROR ("%s: property '%s' of type char: consider changing to "
"int/string", GST_OBJECT_NAME (element),
g_param_spec_get_name (param));
/* fall through */
default:
if (param->value_type == GST_TYPE_CAPS) {
const GstCaps *caps = gst_value_get_caps (&value);
if (!caps)
n_print ("%-23.23s Caps (NULL)", "");
else {
print_caps (caps, " ");
}
} else if (G_IS_PARAM_SPEC_ENUM (param)) {
GEnumValue *values;
guint j = 0;
gint enum_value;
const gchar *value_nick = "";
values = G_ENUM_CLASS (g_type_class_ref (param->value_type))->values;
enum_value = g_value_get_enum (&value);
while (values[j].value_name) {
if (values[j].value == enum_value)
value_nick = values[j].value_nick;
j++;
}
n_print ("%-23.23s Enum \"%s\" Default: %d, \"%s\"", "",
g_type_name (G_VALUE_TYPE (&value)), enum_value, value_nick);
j = 0;
while (values[j].value_name) {
g_print ("\n");
if (_name)
g_print ("%s", _name);
g_print ("%-23.23s (%d): %-16s - %s", "",
values[j].value, values[j].value_nick, values[j].value_name);
j++;
}
/* g_type_class_unref (ec); */
} else if (G_IS_PARAM_SPEC_FLAGS (param)) {
GParamSpecFlags *pflags = G_PARAM_SPEC_FLAGS (param);
GFlagsValue *vals;
gchar *cur;
vals = pflags->flags_class->values;
cur = flags_to_string (vals, g_value_get_flags (&value));
n_print ("%-23.23s Flags \"%s\" Default: 0x%08x, \"%s\"", "",
g_type_name (G_VALUE_TYPE (&value)),
g_value_get_flags (&value), cur);
while (vals[0].value_name) {
g_print ("\n");
if (_name)
g_print ("%s", _name);
g_print ("%-23.23s (0x%08x): %-16s - %s", "",
vals[0].value, vals[0].value_nick, vals[0].value_name);
++vals;
}
g_free (cur);
} else if (G_IS_PARAM_SPEC_OBJECT (param)) {
n_print ("%-23.23s Object of type \"%s\"", "",
g_type_name (param->value_type));
} else if (G_IS_PARAM_SPEC_BOXED (param)) {
n_print ("%-23.23s Boxed pointer of type \"%s\"", "",
g_type_name (param->value_type));
if (param->value_type == GST_TYPE_STRUCTURE) {
const GstStructure *s = gst_value_get_structure (&value);
if (s)
gst_structure_foreach (s, print_field,
(gpointer) " ");
}
} else if (G_IS_PARAM_SPEC_POINTER (param)) {
if (param->value_type != G_TYPE_POINTER) {
n_print ("%-23.23s Pointer of type \"%s\".", "",
g_type_name (param->value_type));
} else {
n_print ("%-23.23s Pointer.", "");
}
} else if (param->value_type == G_TYPE_VALUE_ARRAY) {
GParamSpecValueArray *pvarray = G_PARAM_SPEC_VALUE_ARRAY (param);
if (pvarray->element_spec) {
n_print ("%-23.23s Array of GValues of type \"%s\"", "",
g_type_name (pvarray->element_spec->value_type));
} else {
n_print ("%-23.23s Array of GValues", "");
}
} else if (GST_IS_PARAM_SPEC_FRACTION (param)) {
GstParamSpecFraction *pfraction = GST_PARAM_SPEC_FRACTION (param);
n_print ("%-23.23s Fraction. ", "");
g_print ("Range: %d/%d - %d/%d Default: %d/%d ",
pfraction->min_num, pfraction->min_den,
pfraction->max_num, pfraction->max_den,
gst_value_get_fraction_numerator (&value),
gst_value_get_fraction_denominator (&value));
} else {
n_print ("%-23.23s Unknown type %ld \"%s\"", "",
(glong) param->value_type, g_type_name (param->value_type));
}
break;
}
if (!readable)
g_print (" Write only\n");
else
g_print ("\n");
g_value_reset (&value);
}
if (num_properties == 0)
n_print (" none\n");
g_free (property_specs);
}
int
compare(NODE *s, FTSENT *p)
{
u_int32_t len, val;
#if HAVE_STRUCT_STAT_ST_FLAGS
u_int32_t flags;
#endif
int fd, label;
const char *cp, *tab;
#if !defined(NO_MD5) || !defined(NO_RMD160) || !defined(NO_SHA1) || !defined(NO_SHA2)
char *digestbuf;
#endif
tab = NULL;
label = 0;
switch(s->type) {
case F_BLOCK:
if (!S_ISBLK(p->fts_statp->st_mode))
goto typeerr;
break;
case F_CHAR:
if (!S_ISCHR(p->fts_statp->st_mode))
goto typeerr;
break;
case F_DIR:
if (!S_ISDIR(p->fts_statp->st_mode))
goto typeerr;
break;
case F_FIFO:
if (!S_ISFIFO(p->fts_statp->st_mode))
goto typeerr;
break;
case F_FILE:
if (!S_ISREG(p->fts_statp->st_mode))
goto typeerr;
break;
case F_LINK:
if (!S_ISLNK(p->fts_statp->st_mode))
goto typeerr;
break;
#ifdef S_ISSOCK
case F_SOCK:
if (!S_ISSOCK(p->fts_statp->st_mode))
goto typeerr;
break;
#endif
typeerr: LABEL;
printf("\ttype (%s, %s)\n",
nodetype(s->type), inotype(p->fts_statp->st_mode));
return (label);
}
if (mtree_Wflag)
goto afterpermwhack;
#if HAVE_STRUCT_STAT_ST_FLAGS
if (iflag && !uflag) {
if (s->flags & F_FLAGS)
SETFLAGS(p->fts_statp->st_flags, SP_FLGS);
return (label);
}
if (mflag && !uflag) {
if (s->flags & F_FLAGS)
CLEARFLAGS(p->fts_statp->st_flags, SP_FLGS);
return (label);
}
#endif
if (s->flags & F_DEV &&
(s->type == F_BLOCK || s->type == F_CHAR) &&
s->st_rdev != p->fts_statp->st_rdev) {
LABEL;
printf("%sdevice (%#llx, %#llx",
tab, (long long)s->st_rdev,
(long long)p->fts_statp->st_rdev);
if (uflag) {
if ((unlink(p->fts_accpath) == -1) ||
(mknod(p->fts_accpath,
s->st_mode | nodetoino(s->type),
s->st_rdev) == -1) ||
(lchown(p->fts_accpath, p->fts_statp->st_uid,
p->fts_statp->st_gid) == -1) )
printf(", not modified: %s)\n",
strerror(errno));
else
printf(", modified)\n");
} else
printf(")\n");
tab = "\t";
}
/* Set the uid/gid first, then set the mode. */
if (s->flags & (F_UID | F_UNAME) && s->st_uid != p->fts_statp->st_uid) {
LABEL;
printf("%suser (%lu, %lu",
tab, (u_long)s->st_uid, (u_long)p->fts_statp->st_uid);
if (uflag) {
if (lchown(p->fts_accpath, s->st_uid, -1))
printf(", not modified: %s)\n",
strerror(errno));
else
printf(", modified)\n");
} else
printf(")\n");
tab = "\t";
}
if (s->flags & (F_GID | F_GNAME) && s->st_gid != p->fts_statp->st_gid) {
LABEL;
printf("%sgid (%lu, %lu",
tab, (u_long)s->st_gid, (u_long)p->fts_statp->st_gid);
if (uflag) {
if (lchown(p->fts_accpath, -1, s->st_gid))
printf(", not modified: %s)\n",
strerror(errno));
else
printf(", modified)\n");
}
else
printf(")\n");
tab = "\t";
}
if (s->flags & F_MODE &&
s->st_mode != (p->fts_statp->st_mode & MBITS)) {
if (lflag) {
mode_t tmode, mode;
tmode = s->st_mode;
mode = p->fts_statp->st_mode & MBITS;
/*
* if none of the suid/sgid/etc bits are set,
* then if the mode is a subset of the target,
* skip.
*/
if (!((tmode & ~(S_IRWXU|S_IRWXG|S_IRWXO)) ||
(mode & ~(S_IRWXU|S_IRWXG|S_IRWXO))))
if ((mode | tmode) == tmode)
goto skip;
}
LABEL;
printf("%spermissions (%#lo, %#lo",
tab, (u_long)s->st_mode,
(u_long)p->fts_statp->st_mode & MBITS);
if (uflag) {
if (lchmod(p->fts_accpath, s->st_mode))
printf(", not modified: %s)\n",
strerror(errno));
else
printf(", modified)\n");
}
else
printf(")\n");
tab = "\t";
skip: ;
}
if (s->flags & F_NLINK && s->type != F_DIR &&
s->st_nlink != p->fts_statp->st_nlink) {
LABEL;
printf("%slink count (%lu, %lu)\n",
tab, (u_long)s->st_nlink, (u_long)p->fts_statp->st_nlink);
tab = "\t";
}
if (s->flags & F_SIZE && s->st_size != p->fts_statp->st_size) {
LABEL;
printf("%ssize (%lld, %lld)\n",
tab, (long long)s->st_size,
(long long)p->fts_statp->st_size);
tab = "\t";
}
/*
* XXX
* Since utimes(2) only takes a timeval, there's no point in
* comparing the low bits of the timespec nanosecond field. This
* will only result in mismatches that we can never fix.
*
* Doesn't display microsecond differences.
*/
if (s->flags & F_TIME) {
struct timeval tv[2];
struct stat *ps = p->fts_statp;
time_t smtime = s->st_mtimespec.tv_sec;
#if defined(BSD4_4) && !defined(HAVE_NBTOOL_CONFIG_H)
time_t pmtime = ps->st_mtimespec.tv_sec;
TIMESPEC_TO_TIMEVAL(&tv[0], &s->st_mtimespec);
TIMESPEC_TO_TIMEVAL(&tv[1], &ps->st_mtimespec);
#else
time_t pmtime = (time_t)ps->st_mtime;
tv[0].tv_sec = smtime;
tv[0].tv_usec = 0;
tv[1].tv_sec = pmtime;
tv[1].tv_usec = 0;
#endif
if (tv[0].tv_sec != tv[1].tv_sec ||
tv[0].tv_usec != tv[1].tv_usec) {
LABEL;
printf("%smodification time (%.24s, ",
tab, ctime(&smtime));
printf("%.24s", ctime(&pmtime));
if (tflag) {
tv[1] = tv[0];
if (utimes(p->fts_accpath, tv))
printf(", not modified: %s)\n",
strerror(errno));
else
printf(", modified)\n");
} else
printf(")\n");
tab = "\t";
}
}
#if HAVE_STRUCT_STAT_ST_FLAGS
/*
* XXX
* since lchflags(2) will reset file times, the utimes() above
* may have been useless! oh well, we'd rather have correct
* flags, rather than times?
*/
if ((s->flags & F_FLAGS) && ((s->st_flags != p->fts_statp->st_flags)
|| mflag || iflag)) {
if (s->st_flags != p->fts_statp->st_flags) {
char *f_s;
LABEL;
f_s = flags_to_string(s->st_flags, "none");
printf("%sflags (\"%s\" is not ", tab, f_s);
free(f_s);
f_s = flags_to_string(p->fts_statp->st_flags, "none");
printf("\"%s\"", f_s);
free(f_s);
}
if (uflag) {
if (iflag)
SETFLAGS(0, CH_MASK);
else if (mflag)
CLEARFLAGS(0, SP_FLGS);
else
SETFLAGS(0, (~SP_FLGS & CH_MASK));
} else
printf(")\n");
tab = "\t";
}
#endif /* HAVE_STRUCT_STAT_ST_FLAGS */
/*
* from this point, no more permission checking or whacking
* occurs, only checking of stuff like checksums and symlinks.
*/
afterpermwhack:
if (s->flags & F_CKSUM) {
if ((fd = open(p->fts_accpath, O_RDONLY, 0)) < 0) {
LABEL;
printf("%scksum: %s: %s\n",
tab, p->fts_accpath, strerror(errno));
tab = "\t";
} else if (crc(fd, &val, &len)) {
close(fd);
LABEL;
printf("%scksum: %s: %s\n",
tab, p->fts_accpath, strerror(errno));
tab = "\t";
} else {
close(fd);
if (s->cksum != val) {
LABEL;
printf("%scksum (%lu, %lu)\n",
tab, s->cksum, (unsigned long)val);
}
tab = "\t";
}
}
#ifndef NO_MD5
if (s->flags & F_MD5) {
if ((digestbuf = MD5File(p->fts_accpath, NULL)) == NULL) {
LABEL;
printf("%s%s: %s: %s\n",
tab, MD5KEY, p->fts_accpath, strerror(errno));
tab = "\t";
} else {
if (strcmp(s->md5digest, digestbuf)) {
LABEL;
printf("%s%s (0x%s, 0x%s)\n",
tab, MD5KEY, s->md5digest, digestbuf);
}
tab = "\t";
free(digestbuf);
}
}
#endif /* ! NO_MD5 */
#ifndef NO_RMD160
if (s->flags & F_RMD160) {
if ((digestbuf = RMD160File(p->fts_accpath, NULL)) == NULL) {
LABEL;
printf("%s%s: %s: %s\n",
tab, RMD160KEY, p->fts_accpath, strerror(errno));
tab = "\t";
} else {
if (strcmp(s->rmd160digest, digestbuf)) {
LABEL;
printf("%s%s (0x%s, 0x%s)\n",
tab, RMD160KEY, s->rmd160digest, digestbuf);
}
tab = "\t";
free(digestbuf);
}
}
#endif /* ! NO_RMD160 */
#ifndef NO_SHA1
if (s->flags & F_SHA1) {
if ((digestbuf = SHA1File(p->fts_accpath, NULL)) == NULL) {
LABEL;
printf("%s%s: %s: %s\n",
tab, SHA1KEY, p->fts_accpath, strerror(errno));
tab = "\t";
} else {
if (strcmp(s->sha1digest, digestbuf)) {
LABEL;
printf("%s%s (0x%s, 0x%s)\n",
tab, SHA1KEY, s->sha1digest, digestbuf);
}
tab = "\t";
free(digestbuf);
}
}
#endif /* ! NO_SHA1 */
#ifndef NO_SHA2
if (s->flags & F_SHA256) {
if ((digestbuf = SHA256_File(p->fts_accpath, NULL)) == NULL) {
LABEL;
printf("%s%s: %s: %s\n",
tab, SHA256KEY, p->fts_accpath, strerror(errno));
tab = "\t";
} else {
if (strcmp(s->sha256digest, digestbuf)) {
LABEL;
printf("%s%s (0x%s, 0x%s)\n",
tab, SHA256KEY, s->sha256digest, digestbuf);
}
tab = "\t";
free(digestbuf);
}
}
#ifdef SHA384_BLOCK_LENGTH
if (s->flags & F_SHA384) {
if ((digestbuf = SHA384_File(p->fts_accpath, NULL)) == NULL) {
LABEL;
printf("%s%s: %s: %s\n",
tab, SHA384KEY, p->fts_accpath, strerror(errno));
tab = "\t";
} else {
if (strcmp(s->sha384digest, digestbuf)) {
LABEL;
printf("%s%s (0x%s, 0x%s)\n",
tab, SHA384KEY, s->sha384digest, digestbuf);
}
tab = "\t";
free(digestbuf);
}
}
#endif
if (s->flags & F_SHA512) {
if ((digestbuf = SHA512_File(p->fts_accpath, NULL)) == NULL) {
LABEL;
printf("%s%s: %s: %s\n",
tab, SHA512KEY, p->fts_accpath, strerror(errno));
tab = "\t";
} else {
if (strcmp(s->sha512digest, digestbuf)) {
LABEL;
printf("%s%s (0x%s, 0x%s)\n",
tab, SHA512KEY, s->sha512digest, digestbuf);
}
tab = "\t";
free(digestbuf);
}
}
#endif /* ! NO_SHA2 */
if (s->flags & F_SLINK &&
strcmp(cp = rlink(p->fts_accpath), s->slink)) {
LABEL;
printf("%slink ref (%s, %s", tab, cp, s->slink);
if (uflag) {
if ((unlink(p->fts_accpath) == -1) ||
(symlink(s->slink, p->fts_accpath) == -1) )
printf(", not modified: %s)\n",
strerror(errno));
else
printf(", modified)\n");
} else
printf(")\n");
}
return (label);
}
static int
statd(FTS *t, FTSENT *parent, uid_t *puid, gid_t *pgid, mode_t *pmode,
u_long *pflags)
{
FTSENT *p;
gid_t sgid;
uid_t suid;
mode_t smode;
u_long sflags = 0;
const char *name;
gid_t savegid;
uid_t saveuid;
mode_t savemode;
u_long saveflags;
u_short maxgid, maxuid, maxmode, maxflags;
u_short g[MTREE_MAXGID], u[MTREE_MAXUID],
m[MTREE_MAXMODE], f[MTREE_MAXFLAGS];
static int first = 1;
savegid = *pgid;
saveuid = *puid;
savemode = *pmode;
saveflags = *pflags;
if ((p = fts_children(t, 0)) == NULL) {
if (errno)
mtree_err("%s: %s", RP(parent), strerror(errno));
return (1);
}
memset(g, 0, sizeof(g));
memset(u, 0, sizeof(u));
memset(m, 0, sizeof(m));
memset(f, 0, sizeof(f));
maxuid = maxgid = maxmode = maxflags = 0;
for (; p; p = p->fts_link) {
smode = p->fts_statp->st_mode & MBITS;
if (smode < MTREE_MAXMODE && ++m[smode] > maxmode) {
savemode = smode;
maxmode = m[smode];
}
sgid = p->fts_statp->st_gid;
if (sgid < MTREE_MAXGID && ++g[sgid] > maxgid) {
savegid = sgid;
maxgid = g[sgid];
}
suid = p->fts_statp->st_uid;
if (suid < MTREE_MAXUID && ++u[suid] > maxuid) {
saveuid = suid;
maxuid = u[suid];
}
#if HAVE_STRUCT_STAT_ST_FLAGS
sflags = FLAGS2INDEX(p->fts_statp->st_flags);
if (sflags < MTREE_MAXFLAGS && ++f[sflags] > maxflags) {
saveflags = p->fts_statp->st_flags;
maxflags = f[sflags];
}
#endif
}
/*
* If the /set record is the same as the last one we do not need to
* output a new one. So first we check to see if anything changed.
* Note that we always output a /set record for the first directory.
*/
if (((keys & (F_UNAME | F_UID)) && (*puid != saveuid)) ||
((keys & (F_GNAME | F_GID)) && (*pgid != savegid)) ||
((keys & F_MODE) && (*pmode != savemode)) ||
((keys & F_FLAGS) && (*pflags != saveflags)) ||
first) {
first = 0;
printf("/set type=file");
if (keys & (F_UID | F_UNAME)) {
if (keys & F_UNAME &&
(name = user_from_uid(saveuid, 1)) != NULL)
printf(" uname=%s", name);
else /* if (keys & F_UID) */
printf(" uid=%lu", (u_long)saveuid);
}
if (keys & (F_GID | F_GNAME)) {
if (keys & F_GNAME &&
(name = group_from_gid(savegid, 1)) != NULL)
printf(" gname=%s", name);
else /* if (keys & F_UID) */
printf(" gid=%lu", (u_long)savegid);
}
if (keys & F_MODE)
printf(" mode=%#lo", (u_long)savemode);
if (keys & F_NLINK)
printf(" nlink=1");
if (keys & F_FLAGS)
printf(" flags=%s",
flags_to_string(saveflags, "none"));
printf("\n");
*puid = saveuid;
*pgid = savegid;
*pmode = savemode;
*pflags = saveflags;
}
return (0);
}
static void
cs_cmd_set_mlock(struct sourceinfo *si, int parc, char *parv[])
{
struct mychan *mc;
char modebuf[32], *end, c;
int dir = MTYPE_NUL;
int newlock_on = 0, newlock_off = 0, newlock_limit = 0, flag = 0;
unsigned int mask, changed;
bool mask_ext;
char newlock_key[KEYLEN + 1];
char newlock_ext[ignore_mode_list_size][512];
bool newlock_ext_off[ignore_mode_list_size];
char newext[512];
char ext_plus[ignore_mode_list_size + 1];
char ext_minus[ignore_mode_list_size + 1];
size_t i;
char *letters = strtok(parv[1], " ");
char *arg;
struct metadata *md;
if (!(mc = mychan_find(parv[0])))
{
command_fail(si, fault_nosuch_target, STR_IS_NOT_REGISTERED, parv[0]);
return;
}
if (!chanacs_source_has_flag(mc, si, CA_SET))
{
if (ircd->oper_only_modes == 0 ||
!has_priv(si, PRIV_CHAN_CMODES) ||
!has_priv(si, PRIV_CHAN_ADMIN))
{
command_fail(si, fault_noprivs, STR_NOT_AUTHORIZED);
return;
}
mask = ~ircd->oper_only_modes;
mask_ext = true;
}
else
{
mask = has_priv(si, PRIV_CHAN_CMODES) ? 0 : ircd->oper_only_modes;
mask_ext = false;
}
for (i = 0; i < ignore_mode_list_size; i++)
{
newlock_ext[i][0] = '\0';
newlock_ext_off[i] = false;
}
newlock_key[0] = '\0';
while (letters && *letters)
{
if (*letters != '+' && *letters != '-' && dir == MTYPE_NUL)
{
letters++;
continue;
}
switch ((c = *letters++))
{
case '+':
dir = MTYPE_ADD;
break;
case '-':
dir = MTYPE_DEL;
break;
case 'k':
if (dir == MTYPE_ADD)
{
arg = strtok(NULL, " ");
if (!arg)
{
command_fail(si, fault_badparams, _("You need to specify a value for mode +%c."), 'k');
return;
}
else if (strlen(arg) > KEYLEN)
{
command_fail(si, fault_badparams, _("MLOCK key is too long (%zu > %u)."), strlen(arg), KEYLEN);
return;
}
else if (strchr(arg, ',') || arg[0] == ':')
{
command_fail(si, fault_badparams, _("MLOCK key contains invalid characters."));
return;
}
mowgli_strlcpy(newlock_key, arg, sizeof newlock_key);
newlock_off &= ~CMODE_KEY;
}
else
{
newlock_key[0] = '\0';
newlock_off |= CMODE_KEY;
}
break;
case 'l':
if (dir == MTYPE_ADD)
{
arg = strtok(NULL, " ");
if(!arg)
{
command_fail(si, fault_badparams, _("You need to specify a value for mode +%c."), 'l');
return;
}
if (atol(arg) <= 0)
{
command_fail(si, fault_badparams, _("You must specify a positive integer for limit."));
return;
}
newlock_limit = atol(arg);
newlock_off &= ~CMODE_LIMIT;
}
else
{
newlock_limit = 0;
newlock_off |= CMODE_LIMIT;
}
break;
default:
flag = mode_to_flag(c);
if (flag)
{
if (dir == MTYPE_ADD)
{
newlock_on |= flag;
newlock_off &= ~flag;
}
else
{
newlock_off |= flag;
newlock_on &= ~flag;
}
break;
}
for (i = 0; ignore_mode_list[i].mode != '\0'; i++)
{
if (c == ignore_mode_list[i].mode)
{
if (dir == MTYPE_ADD)
{
arg = strtok(NULL, " ");
if(!arg)
{
command_fail(si, fault_badparams, _("You need to specify a value for mode +%c."), c);
return;
}
if (strlen(arg) > 350)
{
command_fail(si, fault_badparams, _("Invalid value \2%s\2 for mode +%c."), arg, c);
return;
}
if ((mc->chan == NULL || mc->chan->extmodes[i] == NULL || strcmp(mc->chan->extmodes[i], arg)) && !ignore_mode_list[i].check(arg, mc->chan, mc, si->su, si->smu))
{
command_fail(si, fault_badparams, _("Invalid value \2%s\2 for mode +%c."), arg, c);
return;
}
mowgli_strlcpy(newlock_ext[i], arg, sizeof newlock_ext[i]);
newlock_ext_off[i] = false;
}
else
{
newlock_ext[i][0] = '\0';
newlock_ext_off[i] = true;
}
}
}
}
}
// note: the following does not treat +lk and extmodes correctly
changed = ((newlock_on ^ mc->mlock_on) | (newlock_off ^ mc->mlock_off));
changed &= ~mask;
/* if they're only allowed to alter oper only modes, require
* them to actually change such modes -- jilles */
if (!changed && mask_ext)
{
command_fail(si, fault_noprivs, _("You may only alter \2+%s\2 modes."), flags_to_string(~mask));
return;
}
// save it to mychan, leave the modes in mask unchanged -- jilles
mc->mlock_on = (newlock_on & ~mask) | (mc->mlock_on & mask);
mc->mlock_off = (newlock_off & ~mask) | (mc->mlock_off & mask);
if (!(mask & CMODE_LIMIT))
mc->mlock_limit = newlock_limit;
if (!(mask & CMODE_KEY))
{
sfree(mc->mlock_key);
mc->mlock_key = *newlock_key != '\0' ? sstrdup(newlock_key) : NULL;
}
ext_plus[0] = '\0';
ext_minus[0] = '\0';
if (mask_ext)
{
md = metadata_find(mc, "private:mlockext");
if (md != NULL)
{
arg = md->value;
while (*arg != '\0')
{
modebuf[0] = *arg;
modebuf[1] = '\0';
mowgli_strlcat(arg[1] == ' ' || arg[1] == '\0' ? ext_minus : ext_plus, modebuf, ignore_mode_list_size + 1);
arg++;
while (*arg != ' ' && *arg != '\0')
arg++;
while (*arg == ' ')
arg++;
}
}
}
else
{
newext[0] = '\0';
for (i = 0; i < ignore_mode_list_size; i++)
{
if (newlock_ext[i][0] != '\0' || newlock_ext_off[i])
{
if (*newext != '\0')
{
modebuf[0] = ' ';
modebuf[1] = '\0';
mowgli_strlcat(newext, modebuf, sizeof newext);
}
modebuf[0] = ignore_mode_list[i].mode;
modebuf[1] = '\0';
mowgli_strlcat(newext, modebuf, sizeof newext);
mowgli_strlcat(newlock_ext_off[i] ? ext_minus : ext_plus,
modebuf, ignore_mode_list_size + 1);
if (!newlock_ext_off[i])
mowgli_strlcat(newext, newlock_ext[i], sizeof newext);
}
}
if (newext[0] != '\0')
metadata_add(mc, "private:mlockext", newext);
else
metadata_delete(mc, "private:mlockext");
}
end = modebuf;
*end = 0;
if (mc->mlock_on || mc->mlock_key || mc->mlock_limit || *ext_plus)
end += snprintf(end, sizeof(modebuf) - (end - modebuf), "+%s%s%s%s", flags_to_string(mc->mlock_on), mc->mlock_key ? "k" : "", mc->mlock_limit ? "l" : "", ext_plus);
if (mc->mlock_off || *ext_minus)
end += snprintf(end, sizeof(modebuf) - (end - modebuf), "-%s%s%s%s", flags_to_string(mc->mlock_off), mc->mlock_off & CMODE_KEY ? "k" : "", mc->mlock_off & CMODE_LIMIT ? "l" : "", ext_minus);
if (*modebuf)
{
command_success_nodata(si, _("The MLOCK for \2%s\2 has been set to \2%s\2."), mc->name, modebuf);
logcommand(si, CMDLOG_SET, "SET:MLOCK: \2%s\2 to \2%s\2", mc->name, modebuf);
verbose(mc, "\2%s\2 set the mode lock to \2%s\2", get_source_name(si), modebuf);
}
else
{
command_success_nodata(si, _("The MLOCK for \2%s\2 has been removed."), mc->name);
logcommand(si, CMDLOG_SET, "SET:MLOCK:NONE: \2%s\2", mc->name);
}
if (changed & ircd->oper_only_modes)
logcommand(si, CMDLOG_SET, "SET:MLOCK: \2%s\2 to \2%s\2 by \2%s\2", mc->name, *modebuf != '\0' ? modebuf : "+", get_oper_name(si));
check_modes(mc, true);
if (mc->chan != NULL)
mlock_sts(mc->chan);
return;
}
static int
ReportDialog (int argc, char **argv, Coord x, Coord y)
{
void *ptr1, *ptr2, *ptr3;
int type;
char report[2048];
type = SearchScreen (x, y, REPORT_TYPES, &ptr1, &ptr2, &ptr3);
if (type == NO_TYPE)
type =
SearchScreen (x, y, REPORT_TYPES | LOCKED_TYPE, &ptr1, &ptr2, &ptr3);
switch (type)
{
case VIA_TYPE:
{
PinType *via;
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
__r_dump_tree (PCB->Data->via_tree->root, 0);
return 0;
}
#endif
via = (PinType *) ptr2;
if (TEST_FLAG (HOLEFLAG, via))
pcb_snprintf (report, sizeof (report), _("%m+VIA ID# %ld; Flags:%s\n"
"(X,Y) = %$mD.\n"
"It is a pure hole of diameter %$mS.\n"
"Name = \"%s\"."
"%s"), USER_UNITMASK, via->ID, flags_to_string (via->Flags, VIA_TYPE),
via->X, via->Y, via->DrillingHole, EMPTY (via->Name),
TEST_FLAG (LOCKFLAG, via) ? _("It is LOCKED.\n") : "");
else
pcb_snprintf (report, sizeof (report), _("%m+VIA ID# %ld; Flags:%s\n"
"(X,Y) = %$mD.\n"
"Copper width = %$mS. Drill width = %$mS.\n"
"Clearance width in polygons = %$mS.\n"
"Annulus = %$mS.\n"
"Solder mask hole = %$mS (gap = %$mS).\n"
"Name = \"%s\"."
"%s"), USER_UNITMASK, via->ID, flags_to_string (via->Flags, VIA_TYPE),
via->X, via->Y,
via->Thickness,
via->DrillingHole,
via->Clearance / 2,
(via->Thickness - via->DrillingHole) / 2,
via->Mask,
(via->Mask - via->Thickness) / 2,
EMPTY (via->Name), TEST_FLAG (LOCKFLAG, via) ?
_("It is LOCKED.\n") : "");
break;
}
case PIN_TYPE:
{
PinType *Pin;
ElementType *element;
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
__r_dump_tree (PCB->Data->pin_tree->root, 0);
return 0;
}
#endif
Pin = (PinType *) ptr2;
element = (ElementType *) ptr1;
PIN_LOOP (element);
{
if (pin == Pin)
break;
}
END_LOOP;
if (TEST_FLAG (HOLEFLAG, Pin))
pcb_snprintf (report, sizeof (report), _("%m+PIN ID# %ld; Flags:%s\n"
"(X,Y) = %$mD.\n"
"It is a mounting hole. Drill width = %$mS.\n"
"It is owned by element %$mS.\n"
"%s"), USER_UNITMASK, Pin->ID, flags_to_string (Pin->Flags, PIN_TYPE),
Pin->X, Pin->Y, Pin->DrillingHole,
EMPTY (element->Name[1].TextString),
TEST_FLAG (LOCKFLAG, Pin) ? _("It is LOCKED.\n") : "");
else
pcb_snprintf (report, sizeof (report),
_("%m+PIN ID# %ld; Flags:%s\n" "(X,Y) = %$mD.\n"
"Copper width = %$mS. Drill width = %$mS.\n"
"Clearance width to Polygon = %$mS.\n"
"Annulus = %$mS.\n"
"Solder mask hole = %$mS (gap = %$mS).\n"
"Name = \"%s\".\n"
"It is owned by element %s\n as pin number %s.\n"
"%s"), USER_UNITMASK,
Pin->ID, flags_to_string (Pin->Flags, PIN_TYPE),
Pin->X, Pin->Y, Pin->Thickness,
Pin->DrillingHole,
Pin->Clearance / 2,
(Pin->Thickness - Pin->DrillingHole) / 2,
Pin->Mask,
(Pin->Mask - Pin->Thickness) / 2,
EMPTY (Pin->Name),
EMPTY (element->Name[1].TextString), EMPTY (Pin->Number),
TEST_FLAG (LOCKFLAG, Pin) ? _("It is LOCKED.\n") : "");
break;
}
case LINE_TYPE:
{
LineType *line;
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
LayerType *layer = (LayerType *) ptr1;
__r_dump_tree (layer->line_tree->root, 0);
return 0;
}
#endif
line = (LineType *) ptr2;
pcb_snprintf (report, sizeof (report), _("%m+LINE ID# %ld; Flags:%s\n"
"FirstPoint(X,Y) = %$mD, ID = %ld.\n"
"SecondPoint(X,Y) = %$mD, ID = %ld.\n"
"Width = %$mS.\nClearance width in polygons = %$mS.\n"
"It is on layer %d\n"
"and has name \"%s\".\n"
"%s"), USER_UNITMASK,
line->ID, flags_to_string (line->Flags, LINE_TYPE),
line->Point1.X, line->Point1.Y, line->Point1.ID,
line->Point2.X, line->Point2.Y, line->Point2.ID,
line->Thickness, line->Clearance / 2,
GetLayerNumber (PCB->Data, (LayerType *) ptr1),
UNKNOWN (line->Number),
TEST_FLAG (LOCKFLAG, line) ? _("It is LOCKED.\n") : "");
break;
}
case RATLINE_TYPE:
{
RatType *line;
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
__r_dump_tree (PCB->Data->rat_tree->root, 0);
return 0;
}
#endif
line = (RatType *) ptr2;
pcb_snprintf (report, sizeof (report), _("%m+RAT-LINE ID# %ld; Flags:%s\n"
"FirstPoint(X,Y) = %$mD; ID = %ld; "
"connects to layer group %d.\n"
"SecondPoint(X,Y) = %$mD; ID = %ld; "
"connects to layer group %d.\n"),
USER_UNITMASK, line->ID, flags_to_string (line->Flags, LINE_TYPE),
line->Point1.X, line->Point1.Y,
line->Point1.ID, line->group1,
line->Point2.X, line->Point2.Y,
line->Point2.ID, line->group2);
break;
}
case ARC_TYPE:
{
ArcType *Arc;
BoxType *box;
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
LayerType *layer = (LayerType *) ptr1;
__r_dump_tree (layer->arc_tree->root, 0);
return 0;
}
#endif
Arc = (ArcType *) ptr2;
box = GetArcEnds (Arc);
pcb_snprintf (report, sizeof (report), _("%m+ARC ID# %ld; Flags:%s\n"
"CenterPoint(X,Y) = %$mD.\n"
"Radius = %$mS, Thickness = %$mS.\n"
"Clearance width in polygons = %$mS.\n"
"StartAngle = %ma degrees, DeltaAngle = %ma degrees.\n"
"Bounding Box is %$mD, %$mD.\n"
"That makes the end points at %$mD and %$mD.\n"
"It is on layer %d.\n"
"%s"), USER_UNITMASK, Arc->ID, flags_to_string (Arc->Flags, ARC_TYPE),
Arc->X, Arc->Y,
Arc->Width, Arc->Thickness,
Arc->Clearance / 2, Arc->StartAngle, Arc->Delta,
Arc->BoundingBox.X1, Arc->BoundingBox.Y1,
Arc->BoundingBox.X2, Arc->BoundingBox.Y2,
box->X1, box->Y1,
box->X2, box->Y2,
GetLayerNumber (PCB->Data, (LayerType *) ptr1),
TEST_FLAG (LOCKFLAG, Arc) ? _("It is LOCKED.\n") : "");
break;
}
case POLYGON_TYPE:
{
PolygonType *Polygon;
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
LayerType *layer = (LayerType *) ptr1;
__r_dump_tree (layer->polygon_tree->root, 0);
return 0;
}
#endif
Polygon = (PolygonType *) ptr2;
pcb_snprintf (report, sizeof (report), _("%m+POLYGON ID# %ld; Flags:%s\n"
"Its bounding box is %$mD %$mD.\n"
"It has %d points and could store %d more\n"
" without using more memory.\n"
"It has %d holes and resides on layer %d.\n"
"%s"), USER_UNITMASK, Polygon->ID,
flags_to_string (Polygon->Flags, POLYGON_TYPE),
Polygon->BoundingBox.X1, Polygon->BoundingBox.Y1,
Polygon->BoundingBox.X2, Polygon->BoundingBox.Y2,
Polygon->PointN, Polygon->PointMax - Polygon->PointN,
Polygon->HoleIndexN,
GetLayerNumber (PCB->Data, (LayerType *) ptr1),
TEST_FLAG (LOCKFLAG, Polygon) ? _("It is LOCKED.\n") : "");
break;
}
case PAD_TYPE:
{
Coord len;
PadType *Pad;
ElementType *element;
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
__r_dump_tree (PCB->Data->pad_tree->root, 0);
return 0;
}
#endif
Pad = (PadType *) ptr2;
element = (ElementType *) ptr1;
PAD_LOOP (element);
{
{
if (pad == Pad)
break;
}
}
END_LOOP;
len = Distance (Pad->Point1.X, Pad->Point1.Y, Pad->Point2.X, Pad->Point2.Y);
pcb_snprintf (report, sizeof (report), _("%m+PAD ID# %ld; Flags:%s\n"
"FirstPoint(X,Y) = %$mD; ID = %ld.\n"
"SecondPoint(X,Y) = %$mD; ID = %ld.\n"
"Width = %$mS. Length = %$mS.\n"
"Clearance width in polygons = %$mS.\n"
"Solder mask = %$mS x %$mS (gap = %$mS).\n"
"Name = \"%s\".\n"
"It is owned by SMD element %s\n"
" as pin number %s and is on the %s\n"
"side of the board.\n"
"%s"), USER_UNITMASK, Pad->ID,
flags_to_string (Pad->Flags, PAD_TYPE),
Pad->Point1.X, Pad->Point1.Y, Pad->Point1.ID,
Pad->Point2.X, Pad->Point2.Y, Pad->Point2.ID,
Pad->Thickness, len + Pad->Thickness,
Pad->Clearance / 2,
Pad->Mask, len + Pad->Mask,
(Pad->Mask - Pad->Thickness) / 2,
EMPTY (Pad->Name),
EMPTY (element->Name[1].TextString),
EMPTY (Pad->Number),
TEST_FLAG (ONSOLDERFLAG,
Pad) ? _("solder (bottom)") : _("component"),
TEST_FLAG (LOCKFLAG, Pad) ? _("It is LOCKED.\n") : "");
break;
}
case ELEMENT_TYPE:
{
ElementType *element;
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
__r_dump_tree (PCB->Data->element_tree->root, 0);
return 0;
}
#endif
element = (ElementType *) ptr2;
pcb_snprintf (report, sizeof (report), _("%m+ELEMENT ID# %ld; Flags:%s\n"
"BoundingBox %$mD %$mD.\n"
"Descriptive Name \"%s\".\n"
"Name on board \"%s\".\n"
"Part number name \"%s\".\n"
"It is %$mS tall and is located at (X,Y) = %$mD %s.\n"
"Mark located at point (X,Y) = %$mD.\n"
"It is on the %s side of the board.\n"
"%s"), USER_UNITMASK,
element->ID, flags_to_string (element->Flags, ELEMENT_TYPE),
element->BoundingBox.X1, element->BoundingBox.Y1,
element->BoundingBox.X2, element->BoundingBox.Y2,
EMPTY (element->Name[0].TextString),
EMPTY (element->Name[1].TextString),
EMPTY (element->Name[2].TextString),
SCALE_TEXT (FONT_CAPHEIGHT, element->Name[1].Scale),
element->Name[1].X, element->Name[1].Y,
TEST_FLAG (HIDENAMEFLAG, element) ? _(",\n but it's hidden") : "",
element->MarkX, element->MarkY,
TEST_FLAG (ONSOLDERFLAG, element) ? _("solder (bottom)") : _("component"),
TEST_FLAG (LOCKFLAG, element) ? _("It is LOCKED.\n") : "");
break;
}
case TEXT_TYPE:
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
LayerType *layer = (LayerType *) ptr1;
__r_dump_tree (layer->text_tree->root, 0);
return 0;
}
#endif
case ELEMENTNAME_TYPE:
{
char laynum[32];
TextType *text;
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
__r_dump_tree (PCB->Data->name_tree[NAME_INDEX (PCB)]->root, 0);
return 0;
}
#endif
text = (TextType *) ptr2;
if (type == TEXT_TYPE)
sprintf (laynum, _("It is on layer %d."),
GetLayerNumber (PCB->Data, (LayerType *) ptr1));
pcb_snprintf (report, sizeof (report), _("%m+TEXT ID# %ld; Flags:%s\n"
"Located at (X,Y) = %$mD.\n"
"Characters are %$mS tall.\n"
"Value is \"%s\".\n"
"Direction is %d.\n"
"The bounding box is %$mD %$mD.\n"
"%s\n"
"%s"), USER_UNITMASK, text->ID, flags_to_string (text->Flags, TEXT_TYPE),
text->X, text->Y, SCALE_TEXT (FONT_CAPHEIGHT, text->Scale),
text->TextString, text->Direction,
text->BoundingBox.X1, text->BoundingBox.Y1,
text->BoundingBox.X2, text->BoundingBox.Y2,
(type == TEXT_TYPE) ? laynum : _("It is an element name."),
TEST_FLAG (LOCKFLAG, text) ? _("It is LOCKED.\n") : "");
break;
}
case LINEPOINT_TYPE:
case POLYGONPOINT_TYPE:
{
PointType *point = (PointType *) ptr2;
pcb_snprintf (report, sizeof (report), _("%m+POINT ID# %ld.\n"
"Located at (X,Y) = %$mD.\n"
"It belongs to a %s on layer %d.\n"), USER_UNITMASK, point->ID,
point->X, point->Y,
(type == LINEPOINT_TYPE) ?
C_("report", "line") : C_("report", "polygon"),
GetLayerNumber (PCB->Data, (LayerType *) ptr1));
break;
}
case NO_TYPE:
report[0] = '\0';
break;
default:
sprintf (report, _("Unknown\n"));
break;
}
if (report[0] == '\0')
{
Message (_("Nothing found to report on\n"));
return 1;
}
/* create dialog box */
gui->report_dialog (_("Report"), report);
return 0;
}
/*
* Display() takes a linked list of FTSENT structures and passes the list
* along with any other necessary information to the print function. P
* points to the parent directory of the display list.
*/
static void
display(FTSENT *p, FTSENT *list)
{
struct stat *sp;
DISPLAY d;
FTSENT *cur;
NAMES *np;
u_int64_t btotal, stotal;
off_t maxsize;
blkcnt_t maxblock;
ino_t maxinode;
int maxmajor, maxminor;
uint32_t maxnlink;
int bcfile, entries, flen, glen, ulen, maxflags, maxgroup;
unsigned int maxlen;
int maxuser, needstats;
const char *user, *group;
char buf[21]; /* 64 bits == 20 digits, +1 for NUL */
char nuser[12], ngroup[12];
char *flags = NULL;
/*
* If list is NULL there are two possibilities: that the parent
* directory p has no children, or that fts_children() returned an
* error. We ignore the error case since it will be replicated
* on the next call to fts_read() on the post-order visit to the
* directory p, and will be signalled in traverse().
*/
if (list == NULL)
return;
needstats = f_inode || f_longform || f_size;
flen = 0;
maxinode = maxnlink = 0;
bcfile = 0;
maxuser = maxgroup = maxflags = maxlen = 0;
btotal = stotal = maxblock = maxsize = 0;
maxmajor = maxminor = 0;
for (cur = list, entries = 0; cur; cur = cur->fts_link) {
if (cur->fts_info == FTS_ERR || cur->fts_info == FTS_NS) {
warnx("%s: %s",
cur->fts_name, strerror(cur->fts_errno));
cur->fts_number = NO_PRINT;
rval = EXIT_FAILURE;
continue;
}
/*
* P is NULL if list is the argv list, to which different rules
* apply.
*/
if (p == NULL) {
/* Directories will be displayed later. */
if (cur->fts_info == FTS_D && !f_listdir) {
cur->fts_number = NO_PRINT;
continue;
}
} else {
/* Only display dot file if -a/-A set. */
if (cur->fts_name[0] == '.' && !f_listdot) {
cur->fts_number = NO_PRINT;
continue;
}
}
if (cur->fts_namelen > maxlen)
maxlen = cur->fts_namelen;
if (needstats) {
sp = cur->fts_statp;
if (sp->st_blocks > maxblock)
maxblock = sp->st_blocks;
if (sp->st_ino > maxinode)
maxinode = sp->st_ino;
if (sp->st_nlink > maxnlink)
maxnlink = sp->st_nlink;
if (sp->st_size > maxsize)
maxsize = sp->st_size;
if (S_ISCHR(sp->st_mode) || S_ISBLK(sp->st_mode)) {
bcfile = 1;
if (major(sp->st_rdev) > maxmajor)
maxmajor = major(sp->st_rdev);
if (minor(sp->st_rdev) > maxminor)
maxminor = minor(sp->st_rdev);
}
btotal += sp->st_blocks;
stotal += sp->st_size;
if (f_longform) {
if (f_numericonly ||
(user = user_from_uid(sp->st_uid, 0)) ==
NULL) {
(void)snprintf(nuser, sizeof(nuser),
"%u", sp->st_uid);
user = nuser;
}
if (f_numericonly ||
(group = group_from_gid(sp->st_gid, 0)) ==
NULL) {
(void)snprintf(ngroup, sizeof(ngroup),
"%u", sp->st_gid);
group = ngroup;
}
if ((ulen = strlen(user)) > maxuser)
maxuser = ulen;
if ((glen = strlen(group)) > maxgroup)
maxgroup = glen;
if (f_flags) {
flags =
flags_to_string((u_long)sp->st_flags, "-");
if ((flen = strlen(flags)) > maxflags)
maxflags = flen;
} else
flen = 0;
if ((np = malloc(sizeof(NAMES) +
ulen + glen + flen + 2)) == NULL)
err(EXIT_FAILURE, NULL);
np->user = &np->data[0];
(void)strcpy(np->user, user);
np->group = &np->data[ulen + 1];
(void)strcpy(np->group, group);
if (f_flags) {
np->flags = &np->data[ulen + glen + 2];
(void)strcpy(np->flags, flags);
free(flags);
}
cur->fts_pointer = np;
}
}
++entries;
}
if (!entries)
return;
d.list = list;
d.entries = entries;
d.maxlen = maxlen;
if (needstats) {
d.btotal = btotal;
d.stotal = stotal;
if (f_humanize) {
d.s_block = 4; /* min buf length for humanize_number */
} else {
(void)snprintf(buf, sizeof(buf), "%lld",
(long long)howmany(maxblock, blocksize));
d.s_block = strlen(buf);
if (f_commas) /* allow for commas before every third digit */
d.s_block += (d.s_block - 1) / 3;
}
d.s_flags = maxflags;
d.s_group = maxgroup;
(void)snprintf(buf, sizeof(buf), "%llu",
(unsigned long long)maxinode);
d.s_inode = strlen(buf);
(void)snprintf(buf, sizeof(buf), "%u", maxnlink);
d.s_nlink = strlen(buf);
if (f_humanize) {
d.s_size = 4; /* min buf length for humanize_number */
} else {
(void)snprintf(buf, sizeof(buf), "%lld",
(long long)maxsize);
d.s_size = strlen(buf);
if (f_commas) /* allow for commas before every third digit */
d.s_size += (d.s_size - 1) / 3;
}
d.s_user = maxuser;
if (bcfile) {
(void)snprintf(buf, sizeof(buf), "%d", maxmajor);
d.s_major = strlen(buf);
(void)snprintf(buf, sizeof(buf), "%d", maxminor);
d.s_minor = strlen(buf);
if (d.s_major + d.s_minor + 2 > d.s_size)
d.s_size = d.s_major + d.s_minor + 2;
else if (d.s_size - d.s_minor - 2 > d.s_major)
d.s_major = d.s_size - d.s_minor - 2;
} else {
d.s_major = 0;
d.s_minor = 0;
}
}
printfcn(&d);
output = 1;
if (f_longform)
for (cur = list; cur; cur = cur->fts_link)
free(cur->fts_pointer);
}
static void
statf(int indent, FTSENT *p)
{
u_int32_t len, val;
int fd, offset;
const char *name = NULL;
#if !defined(NO_MD5) || !defined(NO_RMD160) || !defined(NO_SHA1) || !defined(NO_SHA2)
char *digestbuf;
#endif
offset = printf("%*s%s%s", indent, "",
S_ISDIR(p->fts_statp->st_mode) ? "" : " ", vispath(p->fts_name));
if (offset > (INDENTNAMELEN + indent))
offset = MAXLINELEN;
else
offset += printf("%*s", (INDENTNAMELEN + indent) - offset, "");
if (!S_ISREG(p->fts_statp->st_mode) && (flavor == F_NETBSD6 || !dflag))
output(indent, &offset, "type=%s",
inotype(p->fts_statp->st_mode));
if (keys & (F_UID | F_UNAME) && p->fts_statp->st_uid != uid) {
if (keys & F_UNAME &&
(name = user_from_uid(p->fts_statp->st_uid, 1)) != NULL)
output(indent, &offset, "uname=%s", name);
if (keys & F_UID || (keys & F_UNAME && name == NULL))
output(indent, &offset, "uid=%u", p->fts_statp->st_uid);
}
if (keys & (F_GID | F_GNAME) && p->fts_statp->st_gid != gid) {
if (keys & F_GNAME &&
(name = group_from_gid(p->fts_statp->st_gid, 1)) != NULL)
output(indent, &offset, "gname=%s", name);
if (keys & F_GID || (keys & F_GNAME && name == NULL))
output(indent, &offset, "gid=%u", p->fts_statp->st_gid);
}
if (keys & F_MODE && (p->fts_statp->st_mode & MBITS) != mode)
output(indent, &offset, "mode=%#o",
p->fts_statp->st_mode & MBITS);
if (keys & F_DEV &&
(S_ISBLK(p->fts_statp->st_mode) || S_ISCHR(p->fts_statp->st_mode)))
output(indent, &offset, "device=%#jx",
(uintmax_t)p->fts_statp->st_rdev);
if (keys & F_NLINK && p->fts_statp->st_nlink != 1)
output(indent, &offset, "nlink=%u", p->fts_statp->st_nlink);
if (keys & F_SIZE &&
(flavor == F_FREEBSD9 || S_ISREG(p->fts_statp->st_mode)))
output(indent, &offset, "size=%ju",
(uintmax_t)p->fts_statp->st_size);
if (keys & F_TIME)
#if defined(BSD4_4) && !defined(HAVE_NBTOOL_CONFIG_H)
output(indent, &offset, "time=%jd.%09ld",
(intmax_t)p->fts_statp->st_mtimespec.tv_sec,
p->fts_statp->st_mtimespec.tv_nsec);
#else
output(indent, &offset, "time=%jd.%09ld",
(intmax_t)p->fts_statp->st_mtime, (long)0);
#endif
if (keys & F_CKSUM && S_ISREG(p->fts_statp->st_mode)) {
if ((fd = open(p->fts_accpath, O_RDONLY, 0)) < 0 ||
crc(fd, &val, &len))
mtree_err("%s: %s", p->fts_accpath, strerror(errno));
close(fd);
output(indent, &offset, "cksum=%lu", (long)val);
}
#ifndef NO_MD5
if (keys & F_MD5 && S_ISREG(p->fts_statp->st_mode)) {
if ((digestbuf = MD5File(p->fts_accpath, NULL)) == NULL)
mtree_err("%s: MD5File failed: %s", p->fts_accpath,
strerror(errno));
output(indent, &offset, "%s=%s", MD5KEY, digestbuf);
free(digestbuf);
}
#endif /* ! NO_MD5 */
#ifndef NO_RMD160
if (keys & F_RMD160 && S_ISREG(p->fts_statp->st_mode)) {
if ((digestbuf = RMD160File(p->fts_accpath, NULL)) == NULL)
mtree_err("%s: RMD160File failed: %s", p->fts_accpath,
strerror(errno));
output(indent, &offset, "%s=%s", RMD160KEY, digestbuf);
free(digestbuf);
}
#endif /* ! NO_RMD160 */
#ifndef NO_SHA1
if (keys & F_SHA1 && S_ISREG(p->fts_statp->st_mode)) {
if ((digestbuf = SHA1File(p->fts_accpath, NULL)) == NULL)
mtree_err("%s: SHA1File failed: %s", p->fts_accpath,
strerror(errno));
output(indent, &offset, "%s=%s", SHA1KEY, digestbuf);
free(digestbuf);
}
#endif /* ! NO_SHA1 */
#ifndef NO_SHA2
if (keys & F_SHA256 && S_ISREG(p->fts_statp->st_mode)) {
if ((digestbuf = SHA256_File(p->fts_accpath, NULL)) == NULL)
mtree_err("%s: SHA256_File failed: %s", p->fts_accpath,
strerror(errno));
output(indent, &offset, "%s=%s", SHA256KEY, digestbuf);
free(digestbuf);
}
#ifdef SHA384_BLOCK_LENGTH
if (keys & F_SHA384 && S_ISREG(p->fts_statp->st_mode)) {
if ((digestbuf = SHA384_File(p->fts_accpath, NULL)) == NULL)
mtree_err("%s: SHA384_File failed: %s", p->fts_accpath,
strerror(errno));
output(indent, &offset, "%s=%s", SHA384KEY, digestbuf);
free(digestbuf);
}
#endif
if (keys & F_SHA512 && S_ISREG(p->fts_statp->st_mode)) {
if ((digestbuf = SHA512_File(p->fts_accpath, NULL)) == NULL)
mtree_err("%s: SHA512_File failed: %s", p->fts_accpath,
strerror(errno));
output(indent, &offset, "%s=%s", SHA512KEY, digestbuf);
free(digestbuf);
}
#endif /* ! NO_SHA2 */
if (keys & F_SLINK &&
(p->fts_info == FTS_SL || p->fts_info == FTS_SLNONE))
output(indent, &offset, "link=%s",
vispath(rlink(p->fts_accpath)));
#if HAVE_STRUCT_STAT_ST_FLAGS
if (keys & F_FLAGS && p->fts_statp->st_flags != flags) {
char *str = flags_to_string(p->fts_statp->st_flags, "none");
output(indent, &offset, "flags=%s", str);
free(str);
}
#endif
putchar('\n');
}
/*
* dump_nodes --
* dump the NODEs from `cur', based in the directory `dir'.
* if pathlast is none zero, print the path last, otherwise print
* it first.
*/
void
dump_nodes(const char *dir, NODE *root, int pathlast)
{
NODE *cur;
char path[MAXPATHLEN];
const char *name;
for (cur = root; cur != NULL; cur = cur->next) {
if (cur->type != F_DIR && !matchtags(cur))
continue;
if (snprintf(path, sizeof(path), "%s%s%s",
dir, *dir ? "/" : "", cur->name)
>= sizeof(path))
mtree_err("Pathname too long.");
if (!pathlast)
printf("%s ", vispath(path));
#define MATCHFLAG(f) ((keys & (f)) && (cur->flags & (f)))
if (MATCHFLAG(F_TYPE))
printf("type=%s ", nodetype(cur->type));
if (MATCHFLAG(F_UID | F_UNAME)) {
if (keys & F_UNAME &&
(name = user_from_uid(cur->st_uid, 1)) != NULL)
printf("uname=%s ", name);
else
printf("uid=%u ", cur->st_uid);
}
if (MATCHFLAG(F_GID | F_GNAME)) {
if (keys & F_GNAME &&
(name = group_from_gid(cur->st_gid, 1)) != NULL)
printf("gname=%s ", name);
else
printf("gid=%u ", cur->st_gid);
}
if (MATCHFLAG(F_MODE))
printf("mode=%#o ", cur->st_mode);
if (MATCHFLAG(F_DEV) &&
(cur->type == F_BLOCK || cur->type == F_CHAR))
printf("device=%#x ", cur->st_rdev);
if (MATCHFLAG(F_NLINK))
printf("nlink=%d ", cur->st_nlink);
if (MATCHFLAG(F_SLINK))
printf("link=%s ", cur->slink);
if (MATCHFLAG(F_SIZE))
printf("size=%lld ", (long long)cur->st_size);
if (MATCHFLAG(F_TIME))
printf("time=%ld.%ld ", (long)cur->st_mtimespec.tv_sec,
cur->st_mtimespec.tv_nsec);
if (MATCHFLAG(F_CKSUM))
printf("cksum=%lu ", cur->cksum);
if (MATCHFLAG(F_MD5))
printf("md5=%s ", cur->md5digest);
if (MATCHFLAG(F_RMD160))
printf("rmd160=%s ", cur->rmd160digest);
if (MATCHFLAG(F_SHA1))
printf("sha1=%s ", cur->sha1digest);
if (MATCHFLAG(F_FLAGS))
printf("flags=%s ",
flags_to_string(cur->st_flags, "none"));
if (MATCHFLAG(F_IGN))
printf("ignore ");
if (MATCHFLAG(F_OPT))
printf("optional ");
if (MATCHFLAG(F_TAGS))
printf("tags=%s ", cur->tags);
puts(pathlast ? vispath(path) : "");
if (cur->child)
dump_nodes(path, cur->child, pathlast);
}
}
static void
print_element_properties_info (GstElement * element)
{
GParamSpec **property_specs;
guint num_properties, i;
gboolean readable;
gboolean first_flag;
property_specs = g_object_class_list_properties
(G_OBJECT_GET_CLASS (element), &num_properties);
n_print ("\n");
n_print ("Element Properties:\n");
for (i = 0; i < num_properties; i++) {
GValue value = { 0, };
GParamSpec *param = property_specs[i];
readable = FALSE;
g_value_init (&value, param->value_type);
n_print (" %-20s: %s\n", g_param_spec_get_name (param),
g_param_spec_get_blurb (param));
first_flag = TRUE;
n_print ("%-23.23s flags: ", "");
if (param->flags & G_PARAM_READABLE) {
g_object_get_property (G_OBJECT (element), param->name, &value);
readable = TRUE;
g_print ("%s%s", (first_flag) ? "" : ", ", _("readable"));
first_flag = FALSE;
}
if (param->flags & G_PARAM_WRITABLE) {
g_print ("%s%s", (first_flag) ? "" : ", ", _("writable"));
first_flag = FALSE;
}
if (param->flags & GST_PARAM_CONTROLLABLE) {
g_print (", %s", _("controllable"));
first_flag = FALSE;
}
if (param->flags & GST_PARAM_MUTABLE_PLAYING) {
g_print (", %s", _("changeable in NULL, READY, PAUSED or PLAYING state"));
} else if (param->flags & GST_PARAM_MUTABLE_PAUSED) {
g_print (", %s", _("changeable only in NULL, READY or PAUSED state"));
} else if (param->flags & GST_PARAM_MUTABLE_READY) {
g_print (", %s", _("changeable only in NULL or READY state"));
}
if (param->flags & ~KNOWN_PARAM_FLAGS) {
g_print ("%s0x%0x", (first_flag) ? "" : ", ",
param->flags & ~KNOWN_PARAM_FLAGS);
}
n_print ("\n");
switch (G_VALUE_TYPE (&value)) {
case G_TYPE_STRING:
{
GParamSpecString *pstring = G_PARAM_SPEC_STRING (param);
n_print ("%-23.23s String. ", "");
if (pstring->default_value == NULL)
g_print ("Default: null ");
else
g_print ("Default: \"%s\" ", pstring->default_value);
if (readable) {
const char *string_val = g_value_get_string (&value);
if (string_val == NULL)
g_print ("Current: null");
else
g_print ("Current: \"%s\"", string_val);
}
break;
}
case G_TYPE_BOOLEAN:
{
GParamSpecBoolean *pboolean = G_PARAM_SPEC_BOOLEAN (param);
n_print ("%-23.23s Boolean. ", "");
g_print ("Default: %s ", (pboolean->default_value ? "true" : "false"));
if (readable)
g_print ("Current: %s",
(g_value_get_boolean (&value) ? "true" : "false"));
break;
}
case G_TYPE_ULONG:
{
GParamSpecULong *pulong = G_PARAM_SPEC_ULONG (param);
n_print ("%-23.23s Unsigned Long. ", "");
g_print ("Range: %lu - %lu Default: %lu ",
pulong->minimum, pulong->maximum, pulong->default_value);
if (readable)
g_print ("Current: %lu", g_value_get_ulong (&value));
break;
}
case G_TYPE_LONG:
{
GParamSpecLong *plong = G_PARAM_SPEC_LONG (param);
n_print ("%-23.23s Long. ", "");
g_print ("Range: %ld - %ld Default: %ld ",
plong->minimum, plong->maximum, plong->default_value);
if (readable)
g_print ("Current: %ld", g_value_get_long (&value));
break;
}
case G_TYPE_UINT:
{
GParamSpecUInt *puint = G_PARAM_SPEC_UINT (param);
n_print ("%-23.23s Unsigned Integer. ", "");
g_print ("Range: %u - %u Default: %u ",
puint->minimum, puint->maximum, puint->default_value);
if (readable)
g_print ("Current: %u", g_value_get_uint (&value));
break;
}
case G_TYPE_INT:
{
GParamSpecInt *pint = G_PARAM_SPEC_INT (param);
n_print ("%-23.23s Integer. ", "");
g_print ("Range: %d - %d Default: %d ",
pint->minimum, pint->maximum, pint->default_value);
if (readable)
g_print ("Current: %d", g_value_get_int (&value));
break;
}
case G_TYPE_UINT64:
{
GParamSpecUInt64 *puint64 = G_PARAM_SPEC_UINT64 (param);
n_print ("%-23.23s Unsigned Integer64. ", "");
g_print ("Range: %" G_GUINT64_FORMAT " - %" G_GUINT64_FORMAT
" Default: %" G_GUINT64_FORMAT " ",
puint64->minimum, puint64->maximum, puint64->default_value);
if (readable)
g_print ("Current: %" G_GUINT64_FORMAT, g_value_get_uint64 (&value));
break;
}
case G_TYPE_INT64:
{
GParamSpecInt64 *pint64 = G_PARAM_SPEC_INT64 (param);
n_print ("%-23.23s Integer64. ", "");
g_print ("Range: %" G_GINT64_FORMAT " - %" G_GINT64_FORMAT
" Default: %" G_GINT64_FORMAT " ",
pint64->minimum, pint64->maximum, pint64->default_value);
if (readable)
g_print ("Current: %" G_GINT64_FORMAT, g_value_get_int64 (&value));
break;
}
case G_TYPE_FLOAT:
{
GParamSpecFloat *pfloat = G_PARAM_SPEC_FLOAT (param);
n_print ("%-23.23s Float. ", "");
g_print ("Range: %15.7g - %15.7g Default: %15.7g ",
pfloat->minimum, pfloat->maximum, pfloat->default_value);
if (readable)
g_print ("Current: %15.7g", g_value_get_float (&value));
break;
}
case G_TYPE_DOUBLE:
{
GParamSpecDouble *pdouble = G_PARAM_SPEC_DOUBLE (param);
n_print ("%-23.23s Double. ", "");
g_print ("Range: %15.7g - %15.7g Default: %15.7g ",
pdouble->minimum, pdouble->maximum, pdouble->default_value);
if (readable)
g_print ("Current: %15.7g", g_value_get_double (&value));
break;
}
default:
if (param->value_type == GST_TYPE_CAPS) {
const GstCaps *caps = gst_value_get_caps (&value);
if (!caps)
n_print ("%-23.23s Caps (NULL)", "");
else {
print_caps (caps, " ");
}
} else if (G_IS_PARAM_SPEC_ENUM (param)) {
GParamSpecEnum *penum = G_PARAM_SPEC_ENUM (param);
GEnumValue *values;
guint j = 0;
gint enum_value;
const gchar *def_val_nick = "", *cur_val_nick = "";
values = G_ENUM_CLASS (g_type_class_ref (param->value_type))->values;
enum_value = g_value_get_enum (&value);
while (values[j].value_name) {
if (values[j].value == enum_value)
cur_val_nick = values[j].value_nick;
if (values[j].value == penum->default_value)
def_val_nick = values[j].value_nick;
j++;
}
n_print
("%-23.23s Enum \"%s\" Default: %d, \"%s\" Current: %d, \"%s\"",
"", g_type_name (G_VALUE_TYPE (&value)), penum->default_value,
def_val_nick, enum_value, cur_val_nick);
j = 0;
while (values[j].value_name) {
g_print ("\n");
if (_name)
g_print ("%s", _name);
g_print ("%-23.23s (%d): %-16s - %s", "",
values[j].value, values[j].value_nick, values[j].value_name);
j++;
}
/* g_type_class_unref (ec); */
} else if (G_IS_PARAM_SPEC_FLAGS (param)) {
GParamSpecFlags *pflags = G_PARAM_SPEC_FLAGS (param);
GFlagsValue *vals;
gchar *cur, *def;
vals = pflags->flags_class->values;
cur = flags_to_string (vals, g_value_get_flags (&value));
def = flags_to_string (vals, pflags->default_value);
n_print
("%-23.23s Flags \"%s\" Default: 0x%08x, \"%s\" Current: 0x%08x, \"%s\"",
"", g_type_name (G_VALUE_TYPE (&value)), pflags->default_value,
def, g_value_get_flags (&value), cur);
while (vals[0].value_name) {
g_print ("\n");
if (_name)
g_print ("%s", _name);
g_print ("%-23.23s (0x%08x): %-16s - %s", "",
vals[0].value, vals[0].value_nick, vals[0].value_name);
++vals;
}
g_free (cur);
g_free (def);
} else if (G_IS_PARAM_SPEC_OBJECT (param)) {
n_print ("%-23.23s Object of type \"%s\"", "",
g_type_name (param->value_type));
} else if (G_IS_PARAM_SPEC_BOXED (param)) {
n_print ("%-23.23s Boxed pointer of type \"%s\"", "",
g_type_name (param->value_type));
} else if (G_IS_PARAM_SPEC_POINTER (param)) {
if (param->value_type != G_TYPE_POINTER) {
n_print ("%-23.23s Pointer of type \"%s\".", "",
g_type_name (param->value_type));
} else {
n_print ("%-23.23s Pointer.", "");
}
} else if (param->value_type == G_TYPE_VALUE_ARRAY) {
GParamSpecValueArray *pvarray = G_PARAM_SPEC_VALUE_ARRAY (param);
if (pvarray->element_spec) {
n_print ("%-23.23s Array of GValues of type \"%s\"", "",
g_type_name (pvarray->element_spec->value_type));
} else {
n_print ("%-23.23s Array of GValues", "");
}
} else if (GST_IS_PARAM_SPEC_FRACTION (param)) {
GstParamSpecFraction *pfraction = GST_PARAM_SPEC_FRACTION (param);
n_print ("%-23.23s Fraction. ", "");
g_print ("Range: %d/%d - %d/%d Default: %d/%d ",
pfraction->min_num, pfraction->min_den,
pfraction->max_num, pfraction->max_den,
pfraction->def_num, pfraction->def_den);
if (readable)
g_print ("Current: %d/%d",
gst_value_get_fraction_numerator (&value),
gst_value_get_fraction_denominator (&value));
} else if (GST_IS_PARAM_SPEC_MINI_OBJECT (param)) {
n_print ("%-23.23s MiniObject of type \"%s\"", "",
g_type_name (param->value_type));
} else {
n_print ("%-23.23s Unknown type %ld \"%s\"", "", param->value_type,
g_type_name (param->value_type));
}
break;
}
if (!readable)
g_print (" Write only\n");
else
g_print ("\n");
g_value_reset (&value);
}
if (num_properties == 0)
n_print (" none\n");
g_free (property_specs);
}
//------------------------------------------------------------------------------
// Name: flags_to_string
// Desc: returns the flags in a string form appropriate for this platform
//------------------------------------------------------------------------------
QString PlatformState::flags_to_string() const {
return flags_to_string(flags());
}
int
main(void)
{
size_t i;
int flags, result;
int ret = 0;
struct testcase *t;
for (i = 0; i < sizeof (testcases) / sizeof (struct testcase); i++) {
t = &testcases[i];
flags = t->flags;
do {
result = fnmatch(t->pattern, t->string, flags);
if (result != t->result)
break;
if (strchr(t->pattern, '\\') == NULL &&
!(flags & FNM_NOESCAPE)) {
flags |= FNM_NOESCAPE;
result = fnmatch(t->pattern, t->string, flags);
if (result != t->result)
break;
flags = t->flags;
}
if (strchr(t->pattern, '\\') != NULL &&
strchr(t->string, '\\') == NULL &&
t->result == FNM_NOMATCH &&
!(flags & (FNM_NOESCAPE | FNM_LEADING_DIR))) {
flags |= FNM_NOESCAPE;
result = fnmatch(t->pattern, t->string, flags);
if (result != t->result)
break;
flags = t->flags;
}
if ((t->string[0] != '.' || t->pattern[0] == '.' ||
t->result == FNM_NOMATCH) &&
!(flags & (FNM_PATHNAME | FNM_PERIOD))) {
flags |= FNM_PERIOD;
result = fnmatch(t->pattern, t->string, flags);
if (result != t->result)
break;
flags = t->flags;
}
if ((strchr(t->string, '/') == NULL ||
t->result == FNM_NOMATCH) &&
!(flags & FNM_PATHNAME)) {
flags |= FNM_PATHNAME;
result = fnmatch(t->pattern, t->string, flags);
if (result != t->result)
break;
flags = t->flags;
}
if ((((t->string[0] != '.' || t->pattern[0] == '.') &&
strstr(t->string, "/.") == NULL) ||
t->result == FNM_NOMATCH) &&
flags & FNM_PATHNAME && !(flags & FNM_PERIOD)) {
flags |= FNM_PERIOD;
result = fnmatch(t->pattern, t->string, flags);
if (result != t->result)
break;
flags = t->flags;
}
if ((((t->string[0] != '.' || t->pattern[0] == '.') &&
strchr(t->string, '/') == NULL) ||
t->result == FNM_NOMATCH) &&
!(flags & (FNM_PATHNAME | FNM_PERIOD))) {
flags |= FNM_PATHNAME | FNM_PERIOD;
result = fnmatch(t->pattern, t->string, flags);
if (result != t->result)
break;
flags = t->flags;
}
if ((strchr(t->string, '/') == NULL ||
t->result == 0) &&
!(flags & FNM_LEADING_DIR)) {
flags |= FNM_LEADING_DIR;
result = fnmatch(t->pattern, t->string, flags);
if (result != t->result)
break;
flags = t->flags;
}
if (t->result == 0 && !(flags & FNM_CASEFOLD)) {
flags |= FNM_CASEFOLD;
result = fnmatch(t->pattern, t->string, flags);
if (result != t->result)
break;
flags = t->flags;
}
if (strchr(t->pattern, '\\') == NULL &&
t->result == 0 &&
!(flags & (FNM_NOESCAPE | FNM_CASEFOLD))) {
flags |= FNM_NOESCAPE | FNM_CASEFOLD;
result = fnmatch(t->pattern, t->string, flags);
if (result != t->result)
break;
flags = t->flags;
}
} while (0);
if (result != t->result) {
printf("fnmatch(\"%s\", \"%s\", %s) != %d (was %d)\n",
t->pattern, t->string, flags_to_string(flags),
t->result, result);
ret = 1;
}
}
return (ret);
}
static int
ReportDialog (int argc, char **argv, int x, int y)
{
void *ptr1, *ptr2, *ptr3;
int type, prec = Settings.grid_units_mm? 4: 2;
char report[2048];
type = SearchScreen (x, y, REPORT_TYPES, &ptr1, &ptr2, &ptr3);
if (type == NO_TYPE)
type =
SearchScreen (x, y, REPORT_TYPES | LOCKED_TYPE, &ptr1, &ptr2, &ptr3);
switch (type)
{
case VIA_TYPE:
{
PinTypePtr via;
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
__r_dump_tree (PCB->Data->via_tree->root, 0);
return 0;
}
#endif
via = (PinTypePtr) ptr2;
if (TEST_FLAG (HOLEFLAG, via))
sprintf (&report[0], "VIA ID# %ld; Flags:%s\n"
"(X,Y) = (%.*f, %.*f) %s.\n"
"It is a pure hole of diameter %.*f %s.\n"
"Name = \"%s\"."
"%s", via->ID, flags_to_string (via->Flags, VIA_TYPE),
prec, units (via->X), prec, UNIT (via->Y),
prec, UNIT (via->DrillingHole),
EMPTY (via->Name), TEST_FLAG (LOCKFLAG,
via) ? "It is LOCKED.\n" :
"");
else
sprintf (&report[0], "VIA ID# %ld; Flags:%s\n"
"(X,Y) = (%.*f, %.*f) %s.\n"
"Copper width = %0.*f %s. Drill width = %0.*f %s.\n"
"Clearance width in polygons = %0.*f %s.\n"
"Annulus = %0.*f %s.\n"
"Solder mask hole = %0.*f %s (gap = %0.*f %s).\n"
"Name = \"%s\"."
"%s", via->ID, flags_to_string (via->Flags, VIA_TYPE),
prec, units (via->X), prec, UNIT (via->Y),
prec, UNIT (via->Thickness),
prec, UNIT (via->DrillingHole),
prec, UNIT (via->Clearance / 2.),
prec, UNIT ((via->Thickness - via->DrillingHole)/2),
prec, UNIT (via->Mask),
prec, UNIT ((via->Mask - via->Thickness)/2),
EMPTY (via->Name), TEST_FLAG (LOCKFLAG, via) ?
"It is LOCKED.\n" : "");
break;
}
case PIN_TYPE:
{
PinTypePtr Pin;
ElementTypePtr element;
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
__r_dump_tree (PCB->Data->pin_tree->root, 0);
return 0;
}
#endif
Pin = (PinTypePtr) ptr2;
element = (ElementTypePtr) ptr1;
PIN_LOOP (element);
{
if (pin == Pin)
break;
}
END_LOOP;
if (TEST_FLAG (HOLEFLAG, Pin))
sprintf (&report[0], "PIN ID# %ld; Flags:%s\n"
"(X,Y) = (%.*f, %.*f) %s.\n"
"It is a mounting hole. Drill width = %0.*f %s.\n"
"It is owned by element %s.\n"
"%s", Pin->ID, flags_to_string (Pin->Flags, PIN_TYPE),
prec, units (Pin->X), prec, UNIT (Pin->Y),
prec, UNIT (Pin->DrillingHole),
EMPTY (element->Name[1].TextString),
TEST_FLAG (LOCKFLAG, Pin) ? "It is LOCKED.\n" : "");
else
sprintf (&report[0],
"PIN ID# %ld; Flags:%s\n" "(X,Y) = (%.*f, %.*f) %s.\n"
"Copper width = %0.*f %s. Drill width = %0.*f %s.\n"
"Clearance width to Polygon = %0.*f %s.\n"
"Annulus = %0.*f %s.\n"
"Solder mask hole = %0.*f %s (gap = %0.*f %s).\n"
"Name = \"%s\".\n"
"It is owned by element %s\n as pin number %s.\n"
"%s",
Pin->ID, flags_to_string (Pin->Flags, PIN_TYPE),
prec, units(Pin->X), prec, UNIT(Pin->Y),
prec, UNIT (Pin->Thickness),
prec, UNIT (Pin->DrillingHole),
prec, UNIT (Pin->Clearance / 2.),
prec, UNIT ((Pin->Thickness - Pin->DrillingHole)/2),
prec, UNIT (Pin->Mask),
prec, UNIT ((Pin->Mask - Pin->Thickness)/2),
EMPTY (Pin->Name),
EMPTY (element->Name[1].TextString), EMPTY (Pin->Number),
TEST_FLAG (LOCKFLAG, Pin) ? "It is LOCKED.\n" : "");
break;
}
case LINE_TYPE:
{
LineTypePtr line;
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
LayerTypePtr layer = (LayerTypePtr) ptr1;
__r_dump_tree (layer->line_tree->root, 0);
return 0;
}
#endif
line = (LineTypePtr) ptr2;
sprintf (&report[0], "LINE ID# %ld; Flags:%s\n"
"FirstPoint(X,Y) = (%.*f, %.*f) %s, ID = %ld.\n"
"SecondPoint(X,Y) = (%.*f, %.*f) %s, ID = %ld.\n"
"Width = %0.*f %s.\nClearance width in polygons = %0.*f %s.\n"
"It is on layer %d\n"
"and has name \"%s\".\n"
"%s",
line->ID, flags_to_string (line->Flags, LINE_TYPE),
prec, units (line->Point1.X), prec, UNIT (line->Point1.Y),
line->Point1.ID, prec, units (line->Point2.X), prec, UNIT (line->Point2.Y),
line->Point2.ID, prec, UNIT (line->Thickness),
prec, UNIT (line->Clearance / 2.), GetLayerNumber (PCB->Data,
(LayerTypePtr) ptr1),
UNKNOWN (line->Number), TEST_FLAG (LOCKFLAG,
line) ? "It is LOCKED.\n" :
"");
break;
}
case RATLINE_TYPE:
{
RatTypePtr line;
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
__r_dump_tree (PCB->Data->rat_tree->root, 0);
return 0;
}
#endif
line = (RatTypePtr) ptr2;
sprintf (&report[0], "RAT-LINE ID# %ld; Flags:%s\n"
"FirstPoint(X,Y) = (%.*f, %.*f) %s; ID = %ld; "
"connects to layer group %d.\n"
"SecondPoint(X,Y) = (%.*f, %.*f) %s; ID = %ld; "
"connects to layer group %d.\n",
line->ID, flags_to_string (line->Flags, LINE_TYPE),
prec, units (line->Point1.X), prec, UNIT (line->Point1.Y),
line->Point1.ID, line->group1,
prec, units (line->Point2.X), prec, UNIT (line->Point2.Y),
line->Point2.ID, line->group2);
break;
}
case ARC_TYPE:
{
ArcTypePtr Arc;
BoxTypePtr box;
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
LayerTypePtr layer = (LayerTypePtr) ptr1;
__r_dump_tree (layer->arc_tree->root, 0);
return 0;
}
#endif
Arc = (ArcTypePtr) ptr2;
box = GetArcEnds (Arc);
sprintf (&report[0], "ARC ID# %ld; Flags:%s\n"
"CenterPoint(X,Y) = (%.*f, %.*f) %s.\n"
"Radius = %0.*f %s, Thickness = %0.*f %s.\n"
"Clearance width in polygons = %0.*f %s.\n"
"StartAngle = %ld degrees, DeltaAngle = %ld degrees.\n"
"Bounding Box is (%.*f,%.*f), (%.*f,%.*f) %s.\n"
"That makes the end points at (%.*f,%.*f) %s and (%.*f,%.*f) %s.\n"
"It is on layer %d.\n"
"%s", Arc->ID, flags_to_string (Arc->Flags, ARC_TYPE),
prec, units(Arc->X), prec, UNIT(Arc->Y),
prec, UNIT (Arc->Width), prec, UNIT (Arc->Thickness),
prec, UNIT (Arc->Clearance / 2.), Arc->StartAngle, Arc->Delta,
prec, units (Arc->BoundingBox.X1),
prec, units (Arc->BoundingBox.Y1),
prec, units (Arc->BoundingBox.X2),
prec, UNIT (Arc->BoundingBox.Y2),
prec, units (box->X1), prec, UNIT (box->Y1),
prec, units (box->X2), prec, UNIT (box->Y2),
GetLayerNumber (PCB->Data, (LayerTypePtr) ptr1),
TEST_FLAG (LOCKFLAG, Arc) ? "It is LOCKED.\n" : "");
break;
}
case POLYGON_TYPE:
{
PolygonTypePtr Polygon;
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
LayerTypePtr layer = (LayerTypePtr) ptr1;
__r_dump_tree (layer->polygon_tree->root, 0);
return 0;
}
#endif
Polygon = (PolygonTypePtr) ptr2;
sprintf (&report[0], "POLYGON ID# %ld; Flags:%s\n"
"Its bounding box is (%.*f,%.*f) (%.*f,%.*f) %s.\n"
"It has %d points and could store %d more\n"
" without using more memory.\n"
"It has %d holes and resides on layer %d.\n"
"%s", Polygon->ID,
flags_to_string (Polygon->Flags, POLYGON_TYPE),
prec, units(Polygon->BoundingBox.X1),
prec, units(Polygon->BoundingBox.Y1),
prec, units(Polygon->BoundingBox.X2),
prec, UNIT(Polygon->BoundingBox.Y2),
Polygon->PointN, Polygon->PointMax - Polygon->PointN,
Polygon->HoleIndexN,
GetLayerNumber (PCB->Data, (LayerTypePtr) ptr1),
TEST_FLAG (LOCKFLAG, Polygon) ? "It is LOCKED.\n" : "");
break;
}
case PAD_TYPE:
{
int len, dx, dy, mgap;
PadTypePtr Pad;
ElementTypePtr element;
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
__r_dump_tree (PCB->Data->pad_tree->root, 0);
return 0;
}
#endif
Pad = (PadTypePtr) ptr2;
element = (ElementTypePtr) ptr1;
PAD_LOOP (element);
{
{
if (pad == Pad)
break;
}
}
END_LOOP;
dx = Pad->Point1.X - Pad->Point2.X;
dy = Pad->Point1.Y - Pad->Point2.Y;
len = sqrt (dx*dx+dy*dy);
mgap = (Pad->Mask - Pad->Thickness)/2;
sprintf (&report[0], "PAD ID# %ld; Flags:%s\n"
"FirstPoint(X,Y) = (%.*f, %.*f) %s; ID = %ld.\n"
"SecondPoint(X,Y) = (%.*f, %.*f) %s; ID = %ld.\n"
"Width = %0.*f %s. Length = %0.*f %s.\n"
"Clearance width in polygons = %0.*f %s.\n"
"Solder mask = %0.*f x %0.*f %s (gap = %0.*f %s).\n"
"Name = \"%s\".\n"
"It is owned by SMD element %s\n"
" as pin number %s and is on the %s\n"
"side of the board.\n"
"%s", Pad->ID,
flags_to_string (Pad->Flags, PAD_TYPE),
prec, units (Pad->Point1.X),
prec, UNIT (Pad->Point1.Y), Pad->Point1.ID,
prec, units (Pad->Point2.X),
prec, UNIT (Pad->Point2.Y), Pad->Point2.ID,
prec, UNIT (Pad->Thickness),
prec, UNIT (len + Pad->Thickness),
prec, UNIT (Pad->Clearance / 2.),
prec, units (Pad->Mask), prec, UNIT (Pad->Mask + len),
prec, UNIT (mgap),
EMPTY (Pad->Name),
EMPTY (element->Name[1].TextString),
EMPTY (Pad->Number),
TEST_FLAG (ONSOLDERFLAG,
Pad) ? "solder (bottom)" : "component",
TEST_FLAG (LOCKFLAG, Pad) ? "It is LOCKED.\n" : "");
break;
}
case ELEMENT_TYPE:
{
ElementTypePtr element;
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
__r_dump_tree (PCB->Data->element_tree->root, 0);
return 0;
}
#endif
element = (ElementTypePtr) ptr2;
sprintf (&report[0], "ELEMENT ID# %ld; Flags:%s\n"
"BoundingBox (%.*f,%.*f) (%.*f,%.*f) %s.\n"
"Descriptive Name \"%s\".\n"
"Name on board \"%s\".\n"
"Part number name \"%s\".\n"
"It is %.*f %s tall and is located at (X,Y) = (%.*f,%.*f)%s.\n"
"Mark located at point (X,Y) = (%.*f,%.*f).\n"
"It is on the %s side of the board.\n"
"%s",
element->ID, flags_to_string (element->Flags, ELEMENT_TYPE),
prec, units(element->BoundingBox.X1),
prec, units (element->BoundingBox.Y1),
prec, units(element->BoundingBox.X2),
prec, UNIT (element->BoundingBox.Y2),
EMPTY (element->Name[0].TextString),
EMPTY (element->Name[1].TextString),
EMPTY (element->Name[2].TextString),
prec, UNIT (0.45 * element->Name[1].Scale * 100.),
prec, units(element->Name[1].X),
prec, units(element->Name[1].Y),
TEST_FLAG (HIDENAMEFLAG, element) ?
",\n but it's hidden" : "", prec, units(element->MarkX),
prec, units(element->MarkY),
TEST_FLAG (ONSOLDERFLAG, element) ? "solder (bottom)" :
"component", TEST_FLAG (LOCKFLAG, element) ?
"It is LOCKED.\n" : "");
break;
}
case TEXT_TYPE:
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
LayerTypePtr layer = (LayerTypePtr) ptr1;
__r_dump_tree (layer->text_tree->root, 0);
return 0;
}
#endif
case ELEMENTNAME_TYPE:
{
char laynum[32];
TextTypePtr text;
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
__r_dump_tree (PCB->Data->name_tree[NAME_INDEX (PCB)]->root, 0);
return 0;
}
#endif
text = (TextTypePtr) ptr2;
if (type == TEXT_TYPE)
sprintf (laynum, "It is on layer %d.",
GetLayerNumber (PCB->Data, (LayerTypePtr) ptr1));
sprintf (&report[0], "TEXT ID# %ld; Flags:%s\n"
"Located at (X,Y) = (%.*f,%.*f) %s.\n"
"Characters are %0.*f %s tall.\n"
"Value is \"%s\".\n"
"Direction is %d.\n"
"The bounding box is (%.*f,%.*f) (%.*f, %.*f) %s.\n"
"%s\n"
"%s", text->ID, flags_to_string (text->Flags, TEXT_TYPE),
prec, units(text->X), prec, UNIT (text->Y),
prec, UNIT (0.45 * text->Scale * 100.),
text->TextString, text->Direction,
prec, units(text->BoundingBox.X1),
prec, units(text->BoundingBox.Y1),
prec, units(text->BoundingBox.X2),
prec, UNIT (text->BoundingBox.Y2),
(type == TEXT_TYPE) ? laynum : "It is an element name.",
TEST_FLAG (LOCKFLAG, text) ? "It is LOCKED.\n" : "");
break;
}
case LINEPOINT_TYPE:
case POLYGONPOINT_TYPE:
{
PointTypePtr point = (PointTypePtr) ptr2;
sprintf (&report[0], "POINT ID# %ld.\n"
"Located at (X,Y) = (%.*f,%.*f) %s.\n"
"It belongs to a %s on layer %d.\n", point->ID,
prec, units (point->X), prec, UNIT (point->Y),
(type == LINEPOINT_TYPE) ? "line" : "polygon",
GetLayerNumber (PCB->Data, (LayerTypePtr) ptr1));
break;
}
case NO_TYPE:
report[0] = '\0';
break;
default:
sprintf (&report[0], "Unknown\n");
break;
}
if (report[0] == '\0')
{
Message (_("Nothing found to report on\n"));
return 1;
}
HideCrosshair (false);
/* create dialog box */
gui->report_dialog ("Report", &report[0]);
RestoreCrosshair (false);
return 0;
}
void check_modes(mychan_t *mychan)
{
char newmodes[40], *newkey = NULL;
char *end = newmodes;
int32_t newlimit = 0;
int modes, set_limit = 0, set_key = 0;
if (!mychan || !mychan->chan)
return;
modes = ~mychan->chan->modes & mychan->mlock_on;
end += snprintf(end, sizeof(newmodes) - (end - newmodes) - 2,
"+%s", flags_to_string(modes));
mychan->chan->modes |= modes;
if (mychan->mlock_limit && mychan->mlock_limit != mychan->chan->limit)
{
*end++ = 'l';
newlimit = mychan->mlock_limit;
mychan->chan->limit = newlimit;
set_limit = 1;
}
if (mychan->mlock_key)
{
if (mychan->chan->key && strcmp(mychan->chan->key, mychan->mlock_key))
{
sts(":%s MODE %s -k %s", svs.nick, mychan->name, mychan->chan->key);
free(mychan->chan->key);
mychan->chan->key = NULL;
}
if (!mychan->chan->key)
{
newkey = mychan->mlock_key;
mychan->chan->key = sstrdup(newkey);
sts(":%s MODE %s +k %s", svs.nick, mychan->name, newkey);
set_key = 0;
}
}
if (end[-1] == '+')
end--;
modes = mychan->chan->modes & mychan->mlock_off;
modes &= ~(CMODE_KEY | CMODE_LIMIT);
end += snprintf(end, sizeof(newmodes) - (end - newmodes) - 1,
"-%s", flags_to_string(modes));
mychan->chan->modes &= ~modes;
if (mychan->chan->limit && (mychan->mlock_off & CMODE_LIMIT))
{
*end++ = 'l';
mychan->chan->limit = 0;
}
if (mychan->chan->key && (mychan->mlock_off & CMODE_KEY))
{
*end++ = 'k';
newkey = sstrdup(mychan->chan->key);
free(mychan->chan->key);
mychan->chan->key = NULL;
set_key = 1;
}
if (end[-1] == '-')
end--;
if (end == newmodes)
return;
*end = 0;
cmode(svs.nick, mychan->name, newmodes,
(set_limit) ? itoa(newlimit) : (set_key) ? newkey : "");
if (newkey && !mychan->chan->key)
free(newkey);
}
static int pgfuse_create( const char *path, mode_t mode, struct fuse_file_info *fi )
{
PgFuseData *data = (PgFuseData *)fuse_get_context( )->private_data;
int64_t id;
PgMeta meta;
char *copy_path;
char *parent_path;
char *new_file;
int64_t parent_id;
int64_t res;
PGconn *conn;
if( data->verbose ) {
char *s = flags_to_string( fi->flags );
syslog( LOG_INFO, "Create '%s' in mode '%o' on '%s' with flags '%s', thread #%u",
path, mode, data->mountpoint, s, THREAD_ID );
if( *s != '<' ) free( s );
}
ACQUIRE( conn );
PSQL_BEGIN( conn );
if( data->read_only ) {
PSQL_ROLLBACK( conn ); RELEASE( conn );
return -EROFS;
}
id = psql_read_meta_from_path( conn, path, &meta );
if( id < 0 && id != -ENOENT ) {
PSQL_ROLLBACK( conn ); RELEASE( conn );
return id;
}
if( id >= 0 ) {
if( data->verbose ) {
syslog( LOG_DEBUG, "Id for dir '%s' is %"PRIi64", thread #%u",
path, id, THREAD_ID );
}
if( S_ISDIR( meta.mode ) ) {
PSQL_ROLLBACK( conn ); RELEASE( conn );
return -EISDIR;
}
if( ( fi->flags & O_CREAT ) && (fi->flags & O_EXCL ) ) {
PSQL_ROLLBACK( conn ); RELEASE( conn );
return -EEXIST;
}
res = psql_truncate( conn, data->block_size, id, path, 0 );
if( res < 0 ) {
PSQL_ROLLBACK( conn ); RELEASE( conn );
return res;
}
meta.size = 0;
res = psql_write_meta( conn, id, path, meta );
if( res < 0 ) {
PSQL_ROLLBACK( conn ); RELEASE( conn );
return res;
}
}
copy_path = strdup( path );
if( copy_path == NULL ) {
syslog( LOG_ERR, "Out of memory in Create '%s'!", path );
PSQL_ROLLBACK( conn ); RELEASE( conn );
return -ENOMEM;
}
parent_path = dirname( copy_path );
parent_id = psql_read_meta_from_path( conn, parent_path, &meta );
if( parent_id < 0 ) {
PSQL_ROLLBACK( conn ); RELEASE( conn );
return parent_id;
}
if( !S_ISDIR(meta.mode ) ) {
PSQL_ROLLBACK( conn ); RELEASE( conn );
return -ENOENT;
}
if( data->verbose ) {
syslog( LOG_DEBUG, "Parent_id for new file '%s' in dir '%s' is %"PRIi64", thread #%u",
path, parent_path, parent_id, THREAD_ID );
}
free( copy_path );
copy_path = strdup( path );
if( copy_path == NULL ) {
free( parent_path );
syslog( LOG_ERR, "Out of memory in Create '%s'!", path );
PSQL_ROLLBACK( conn ); RELEASE( conn );
return -ENOMEM;
}
new_file = basename( copy_path );
meta.size = 0;
meta.mode = mode;
meta.uid = fuse_get_context( )->uid;
meta.gid = fuse_get_context( )->gid;
meta.ctime = now( );
meta.mtime = meta.ctime;
meta.atime = meta.ctime;
res = psql_create_file( conn, parent_id, path, new_file, meta );
if( res < 0 ) {
free( copy_path );
PSQL_ROLLBACK( conn ); RELEASE( conn );
return res;
}
id = psql_read_meta_from_path( conn, path, &meta );
if( id < 0 ) {
free( copy_path );
PSQL_ROLLBACK( conn ); RELEASE( conn );
return res;
}
if( data->verbose ) {
syslog( LOG_DEBUG, "Id for new file '%s' is %"PRIi64", thread #%u",
path, id, THREAD_ID );
}
fi->fh = id;
free( copy_path );
PSQL_COMMIT( conn ); RELEASE( conn );
return res;
}
int netlink_parse_interface_link(struct nlmsghdr *nh, void *data)
{
struct ifaces_list ** iface_list = ( struct ifaces_list **) data;
struct ifaces_list *tmp;
struct iface_entry iface_tmp;
struct iface_entry * iff;
struct ifinfomsg *iface;
struct rtattr *attribute;
uint32_t len;
uint32_t newsize;
// stumbled upon an old system with 4 bytes padding between nlmsghdr and ifinfomsg, try to detect it
iface = NLMSG_DATA(nh);
if (!likely_ifinfomsg(iface)) {
iface = (unsigned char *)iface + 4;
dprintf("Adjusted iface at +4");
}
//dprintf("ifi_family : 0x%x , ifi_type : 0x%x, ifi_index : 0x%x",iface->ifi_family, iface->ifi_type, iface->ifi_index);
len = nh->nlmsg_len - NLMSG_LENGTH(sizeof(*iface));
memset(&iface_tmp, 0, sizeof(iface_tmp));
// index of the interface
iface_tmp.index = iface->ifi_index;
//flags of the interface, string version
flags_to_string(iface->ifi_flags, iface_tmp.flags, FLAGS_LEN);
for (attribute = IFLA_RTA(iface); RTA_OK(attribute, len); attribute = RTA_NEXT(attribute, len))
{
switch(attribute->rta_type)
{
case IFLA_IFNAME:
strncpy(iface_tmp.name, (unsigned char *) RTA_DATA(attribute), IFNAMSIZ);
break;
case IFLA_ADDRESS:
memcpy(iface_tmp.hwaddr, (unsigned char *) RTA_DATA(attribute), 6);
break;
case IFLA_MTU:
iface_tmp.mtu = *(uint32_t *)RTA_DATA(attribute);
break;
default:
break;
}
}
newsize = sizeof(struct ifaces_list);
newsize += ((*iface_list)->entries + 1) * sizeof(struct iface_entry);
tmp = realloc(*iface_list, newsize);
if(tmp == NULL) {
return ENOMEM;
}
iff = &(tmp->ifaces[tmp->entries]);
memset(iff, 0, sizeof(struct iface_entry));
iff->index = iface_tmp.index;
strncpy(iff->name, iface_tmp.name, IFNAMSIZ);
memcpy(iff->hwaddr, iface_tmp.hwaddr, 6);
strncpy(iff->flags, iface_tmp.flags, FLAGS_LEN);
iff->mtu = iface_tmp.mtu;
dprintf("iff->index = %d, iff->name = %s, iff->hwaddr = %02x:%02x:%02x:%02x:%02x:%02x, iff->mtu = %d, iff->flags = %s, real_flags = 0x%08x", iff->index, iff->name,
*(unsigned char *)(iff->hwaddr), *(unsigned char *)(iff->hwaddr+1),*(unsigned char *)(iff->hwaddr+2),
*(unsigned char *)(iff->hwaddr+3), *(unsigned char *)(iff->hwaddr+4), *(unsigned char *)(iff->hwaddr+5), iff->mtu, iff->flags, iface->ifi_flags);
tmp->entries++;
*iface_list = tmp;
return 0;
}
static void
statf(FTSENT *p)
{
u_int32_t len, val;
int fd, indent;
const char *name;
#if !defined(NO_MD5) || !defined(NO_RMD160) || !defined(NO_SHA1) || !defined(NO_SHA2)
char *digestbuf;
#endif
indent = printf("%s%s",
S_ISDIR(p->fts_statp->st_mode) ? "" : " ", vispath(p->fts_name));
if (indent > INDENTNAMELEN)
indent = MAXLINELEN;
else
indent += printf("%*s", INDENTNAMELEN - indent, "");
if (!S_ISREG(p->fts_statp->st_mode))
output(&indent, "type=%s", inotype(p->fts_statp->st_mode));
if (keys & (F_UID | F_UNAME) && p->fts_statp->st_uid != uid) {
if (keys & F_UNAME &&
(name = user_from_uid(p->fts_statp->st_uid, 1)) != NULL)
output(&indent, "uname=%s", name);
else /* if (keys & F_UID) */
output(&indent, "uid=%u", p->fts_statp->st_uid);
}
if (keys & (F_GID | F_GNAME) && p->fts_statp->st_gid != gid) {
if (keys & F_GNAME &&
(name = group_from_gid(p->fts_statp->st_gid, 1)) != NULL)
output(&indent, "gname=%s", name);
else /* if (keys & F_GID) */
output(&indent, "gid=%u", p->fts_statp->st_gid);
}
if (keys & F_MODE && (p->fts_statp->st_mode & MBITS) != mode)
output(&indent, "mode=%#o", p->fts_statp->st_mode & MBITS);
if (keys & F_DEV &&
(S_ISBLK(p->fts_statp->st_mode) || S_ISCHR(p->fts_statp->st_mode)))
output(&indent, "device=%#llx",
(long long)p->fts_statp->st_rdev);
if (keys & F_NLINK && p->fts_statp->st_nlink != 1)
output(&indent, "nlink=%u", p->fts_statp->st_nlink);
if (keys & F_SIZE && S_ISREG(p->fts_statp->st_mode))
output(&indent, "size=%lld", (long long)p->fts_statp->st_size);
if (keys & F_TIME)
#if defined(BSD4_4) && !defined(HAVE_NBTOOL_CONFIG_H)
output(&indent, "time=%ld.%ld",
(long)p->fts_statp->st_mtimespec.tv_sec,
p->fts_statp->st_mtimespec.tv_nsec);
#else
output(&indent, "time=%ld.%ld",
(long)p->fts_statp->st_mtime, (long)0);
#endif
if (keys & F_CKSUM && S_ISREG(p->fts_statp->st_mode)) {
if ((fd = open(p->fts_accpath, O_RDONLY, 0)) < 0 ||
crc(fd, &val, &len))
mtree_err("%s: %s", p->fts_accpath, strerror(errno));
close(fd);
output(&indent, "cksum=%lu", (long)val);
}
#ifndef NO_MD5
if (keys & F_MD5 && S_ISREG(p->fts_statp->st_mode)) {
if ((digestbuf = MD5File(p->fts_accpath, NULL)) == NULL)
mtree_err("%s: MD5File failed: %s", p->fts_accpath, strerror(errno));
output(&indent, "md5=%s", digestbuf);
free(digestbuf);
}
#endif /* ! NO_MD5 */
#ifndef NO_RMD160
if (keys & F_RMD160 && S_ISREG(p->fts_statp->st_mode)) {
if ((digestbuf = RMD160File(p->fts_accpath, NULL)) == NULL)
mtree_err("%s: RMD160File failed: %s", p->fts_accpath, strerror(errno));
output(&indent, "rmd160=%s", digestbuf);
free(digestbuf);
}
#endif /* ! NO_RMD160 */
#ifndef NO_SHA1
if (keys & F_SHA1 && S_ISREG(p->fts_statp->st_mode)) {
if ((digestbuf = SHA1File(p->fts_accpath, NULL)) == NULL)
mtree_err("%s: SHA1File failed: %s", p->fts_accpath, strerror(errno));
output(&indent, "sha1=%s", digestbuf);
free(digestbuf);
}
#endif /* ! NO_SHA1 */
#ifndef NO_SHA2
if (keys & F_SHA256 && S_ISREG(p->fts_statp->st_mode)) {
if ((digestbuf = SHA256_File(p->fts_accpath, NULL)) == NULL)
mtree_err("%s: SHA256_File failed: %s", p->fts_accpath, strerror(errno));
output(&indent, "sha256=%s", digestbuf);
free(digestbuf);
}
if (keys & F_SHA384 && S_ISREG(p->fts_statp->st_mode)) {
if ((digestbuf = SHA384_File(p->fts_accpath, NULL)) == NULL)
mtree_err("%s: SHA384_File failed: %s", p->fts_accpath, strerror(errno));
output(&indent, "sha384=%s", digestbuf);
free(digestbuf);
}
if (keys & F_SHA512 && S_ISREG(p->fts_statp->st_mode)) {
if ((digestbuf = SHA512_File(p->fts_accpath, NULL)) == NULL)
mtree_err("%s: SHA512_File failed: %s", p->fts_accpath, strerror(errno));
output(&indent, "sha512=%s", digestbuf);
free(digestbuf);
}
#endif /* ! NO_SHA2 */
if (keys & F_SLINK &&
(p->fts_info == FTS_SL || p->fts_info == FTS_SLNONE))
output(&indent, "link=%s", vispath(rlink(p->fts_accpath)));
#if HAVE_STRUCT_STAT_ST_FLAGS
if (keys & F_FLAGS && p->fts_statp->st_flags != flags)
output(&indent, "flags=%s",
flags_to_string(p->fts_statp->st_flags, "none"));
#endif
putchar('\n');
}
int sys_vswprintf(TCHAR* buffer, size_t count, const TCHAR* format, va_list argptr)
{
// To help quickly detect incorrect 'count' values, fill the buffer with 0s
memset(buffer, 0, count*sizeof(TCHAR));
/*
Format 'variable' specifications are (in pseudo-Perl regexp syntax):
% (\d+$)? ['-+ #0]? (* | \d+)? (. (* | \d*) )? (hh|h|l|ll|j|z|t|L)? [diouxXfFeEgGaAcspnCS%]
position flags width precision length type
*/
/**** Parse the format string into constant/variable chunks ****/
std::vector<FormatChunk*> specs;
std::tstring stringchunk;
TCHAR chr;
#define readchar(x) if ((x = *format++) == '\0') { delete s; goto finished_reading; }
while ((chr = *format++) != '\0')
{
if (chr == _T('%'))
{
// Handle %% correctly
if (*format == _T('%'))
{
stringchunk += _T('%');
continue;
}
// End the current string and start a new spec chunk
if (stringchunk.length())
{
specs.push_back(new FormatString(stringchunk));
stringchunk = _T("");
}
FormatVariable *s = new FormatVariable;
s->position = -1;
s->flags = 0;
s->width = 0;
s->precision = 0;
s->length = 0;
s->type = 0;
// Read either the position or the width
int number = 0;
while (1)
{
readchar(chr);
// Read flags (but not if it's a 0 appearing after other digits)
if (!number && get_flag(chr))
s->flags = (char)(s->flags|get_flag(chr));
// Read decimal numbers (position or width)
else if (isdigit(chr))
number = number*10 + (chr-'0');
// If we've reached a $, 'number' was the position,
// so remember it and start getting the width
else if (chr == _T('$'))
{
s->position = number;
number = 0;
}
// End of the number section
else
{
// Remember the width
s->width = number;
// Start looking for a precision
if (chr == _T('.'))
{
// Found a precision: read the digits
number = 0;
while (1)
{
readchar(chr);
if (isdigit(chr))
number = number*10 + (chr-'0');
else
{
s->precision = number;
break;
}
}
}
// Finished dealing with any precision.
// Now check for length and type codes.
if (chr == _T('I'))
{
DEBUG_WARN_ERR(ERR::LOGIC); // MSVC-style \"%I64\" is not allowed!
}
if (is_lengthmod(chr))
{
s->length = chr;
// Check for ll and hh
if (chr == _T('l') || chr == _T('h'))
{
if (*format == chr)
{
s->length |= (chr << 8);
++format;
}
}
readchar(chr);
}
s->type = (char)chr;
specs.push_back(s);
break;
}
}
}
else
{
stringchunk += chr;
}
}
#undef readchar
finished_reading:
if (stringchunk.length())
{
specs.push_back(new FormatString(stringchunk));
stringchunk = _T("");
}
/**** Build a new format string (to pass to the system printf) ****/
std::tstring newformat;
std::vector<int> varsizes; // stores the size of each variable type, to allow stack twiddling
typedef std::vector<FormatChunk*>::iterator ChunkIt;
for (ChunkIt it = specs.begin(); it != specs.end(); ++it)
{
if ((*it)->ChunkType() == 0)
{
FormatVariable* s = static_cast<FormatVariable*>(*it);
if (s->position > 0)
{
// Grow if necessary
if (s->position >= (int)varsizes.size())
varsizes.resize(s->position+1, -1);
// Store the size of the current type
varsizes[s->position] = type_size(s->type, s->length);
}
newformat += _T("%");
if (s->flags)
newformat += flags_to_string(s->flags);
if (s->width == -1)
newformat += '*';
else if (s->width)
newformat += to_string(s->width);
if (s->precision)
{
newformat += '.';
if (s->precision == -1)
newformat += '*';
else
newformat += to_string(s->precision);
}
if (s->length)
{
if (s->length > 256)
{
if (s->length == 0x00006c6c)
#if USE_I64_FORMAT
newformat += "I64";
#else
newformat += _T("ll");
#endif
else if (s->length == 0x00006868)
newformat += _T("hh");
}
else
{
newformat += (char) s->length;
}
}
/*
* dump_nodes --
* dump the NODEs from `cur', based in the directory `dir'.
* if pathlast is none zero, print the path last, otherwise print
* it first.
*/
void
dump_nodes(const char *dir, NODE *root, int pathlast)
{
NODE *cur;
char path[MAXPATHLEN];
const char *name;
char *str;
char *p, *q;
for (cur = root; cur != NULL; cur = cur->next) {
if (cur->type != F_DIR && !matchtags(cur))
continue;
if (snprintf(path, sizeof(path), "%s%s%s",
dir, *dir ? "/" : "", cur->name)
>= (int)sizeof(path))
mtree_err("Pathname too long.");
if (!pathlast)
printf("%s", vispath(path));
#define MATCHFLAG(f) ((keys & (f)) && (cur->flags & (f)))
if (MATCHFLAG(F_TYPE))
appendfield(pathlast, "type=%s", nodetype(cur->type));
if (MATCHFLAG(F_UID | F_UNAME)) {
if (keys & F_UNAME &&
(name = user_from_uid(cur->st_uid, 1)) != NULL)
appendfield(pathlast, "uname=%s", name);
else
appendfield(pathlast, "uid=%u", cur->st_uid);
}
if (MATCHFLAG(F_GID | F_GNAME)) {
if (keys & F_GNAME &&
(name = group_from_gid(cur->st_gid, 1)) != NULL)
appendfield(pathlast, "gname=%s", name);
else
appendfield(pathlast, "gid=%u", cur->st_gid);
}
if (MATCHFLAG(F_MODE))
appendfield(pathlast, "mode=%#o", cur->st_mode);
if (MATCHFLAG(F_DEV) &&
(cur->type == F_BLOCK || cur->type == F_CHAR))
appendfield(pathlast, "device=%#llx", (long long)cur->st_rdev);
if (MATCHFLAG(F_NLINK))
appendfield(pathlast, "nlink=%d", cur->st_nlink);
if (MATCHFLAG(F_SLINK))
appendfield(pathlast, "link=%s", vispath(cur->slink));
if (MATCHFLAG(F_SIZE))
appendfield(pathlast, "size=%lld", (long long)cur->st_size);
if (MATCHFLAG(F_TIME))
appendfield(pathlast, "time=%lld.%09ld",
(long long)cur->st_mtimespec.tv_sec,
cur->st_mtimespec.tv_nsec);
if (MATCHFLAG(F_CKSUM))
appendfield(pathlast, "cksum=%lu", cur->cksum);
if (MATCHFLAG(F_MD5))
appendfield(pathlast, "%s=%s", MD5KEY, cur->md5digest);
if (MATCHFLAG(F_RMD160))
appendfield(pathlast, "%s=%s", RMD160KEY,
cur->rmd160digest);
if (MATCHFLAG(F_SHA1))
appendfield(pathlast, "%s=%s", SHA1KEY,
cur->sha1digest);
if (MATCHFLAG(F_SHA256))
appendfield(pathlast, "%s=%s", SHA256KEY,
cur->sha256digest);
if (MATCHFLAG(F_SHA384))
appendfield(pathlast, "%s=%s", SHA384KEY,
cur->sha384digest);
if (MATCHFLAG(F_SHA512))
appendfield(pathlast, "%s=%s", SHA512KEY,
cur->sha512digest);
if (MATCHFLAG(F_FLAGS)) {
str = flags_to_string(cur->st_flags, "none");
appendfield(pathlast, "flags=%s", str);
free(str);
}
if (MATCHFLAG(F_IGN))
appendfield(pathlast, "ignore");
if (MATCHFLAG(F_OPT))
appendfield(pathlast, "optional");
if (MATCHFLAG(F_TAGS)) {
/* don't output leading or trailing commas */
p = cur->tags;
while (*p == ',')
p++;
q = p + strlen(p);
while(q > p && q[-1] == ',')
q--;
appendfield(pathlast, "tags=%.*s", (int)(q - p), p);
}
puts(pathlast ? vispath(path) : "");
if (cur->child)
dump_nodes(path, cur->child, pathlast);
}
}
int
main(int argc, char *argv[])
{
size_t i, n;
int opt, flags, result, extra, errors;
struct testcase *t;
while ((opt = getopt(argc, argv, "s:")) != -1) {
switch (opt) {
case 's':
return (write_sh_tests(argv[0], atoi(optarg)));
default:
fprintf(stderr, "usage: %s [-s num]\n", argv[0]);
fprintf(stderr, "-s option writes tests for sh(1), num is 1 or 2\n");
exit(1);
}
}
n = sizeof(testcases) / sizeof(testcases[0]);
errors = 0;
printf("1..%zu\n", n);
for (i = 0; i < n; i++) {
t = &testcases[i];
flags = t->flags;
extra = 0;
do {
result = fnmatch(t->pattern, t->string, flags);
if (result != t->result)
break;
if (strchr(t->pattern, '\\') == NULL &&
!(flags & FNM_NOESCAPE)) {
flags |= FNM_NOESCAPE;
result = fnmatch(t->pattern, t->string, flags);
if (result != t->result)
break;
flags = t->flags;
extra++;
}
if (strchr(t->pattern, '\\') != NULL &&
strchr(t->string, '\\') == NULL &&
t->result == FNM_NOMATCH &&
!(flags & (FNM_NOESCAPE | FNM_LEADING_DIR))) {
flags |= FNM_NOESCAPE;
result = fnmatch(t->pattern, t->string, flags);
if (result != t->result)
break;
flags = t->flags;
extra++;
}
if ((t->string[0] != '.' || t->pattern[0] == '.' ||
t->result == FNM_NOMATCH) &&
!(flags & (FNM_PATHNAME | FNM_PERIOD))) {
flags |= FNM_PERIOD;
result = fnmatch(t->pattern, t->string, flags);
if (result != t->result)
break;
flags = t->flags;
extra++;
}
if ((strchr(t->string, '/') == NULL ||
t->result == FNM_NOMATCH) &&
!(flags & FNM_PATHNAME)) {
flags |= FNM_PATHNAME;
result = fnmatch(t->pattern, t->string, flags);
if (result != t->result)
break;
flags = t->flags;
extra++;
}
if ((((t->string[0] != '.' || t->pattern[0] == '.') &&
strstr(t->string, "/.") == NULL) ||
t->result == FNM_NOMATCH) &&
flags & FNM_PATHNAME && !(flags & FNM_PERIOD)) {
flags |= FNM_PERIOD;
result = fnmatch(t->pattern, t->string, flags);
if (result != t->result)
break;
flags = t->flags;
extra++;
}
if ((((t->string[0] != '.' || t->pattern[0] == '.') &&
strchr(t->string, '/') == NULL) ||
t->result == FNM_NOMATCH) &&
!(flags & (FNM_PATHNAME | FNM_PERIOD))) {
flags |= FNM_PATHNAME | FNM_PERIOD;
result = fnmatch(t->pattern, t->string, flags);
if (result != t->result)
break;
flags = t->flags;
extra++;
}
if ((strchr(t->string, '/') == NULL || t->result == 0)
&& !(flags & FNM_LEADING_DIR)) {
flags |= FNM_LEADING_DIR;
result = fnmatch(t->pattern, t->string, flags);
if (result != t->result)
break;
flags = t->flags;
extra++;
}
if (t->result == 0 && !(flags & FNM_CASEFOLD)) {
flags |= FNM_CASEFOLD;
result = fnmatch(t->pattern, t->string, flags);
if (result != t->result)
break;
flags = t->flags;
extra++;
}
if (strchr(t->pattern, '\\') == NULL &&
t->result == 0 &&
!(flags & (FNM_NOESCAPE | FNM_CASEFOLD))) {
flags |= FNM_NOESCAPE | FNM_CASEFOLD;
result = fnmatch(t->pattern, t->string, flags);
if (result != t->result)
break;
flags = t->flags;
extra++;
}
} while (0);
if (result == t->result)
printf("ok %zu - fnmatch(\"%s\", \"%s\", %s) = %d (+%d)\n",
i + 1, t->pattern, t->string,
flags_to_string(flags),
result, extra);
else {
printf("not ok %zu - fnmatch(\"%s\", \"%s\", %s) = %d != %d\n",
i + 1, t->pattern, t->string,
flags_to_string(flags),
result, t->result);
errors = 1;
}
}
return (errors);
}