void Socket::setMode(Mode m)
{
TRACE("setMode() %s -> %s", mode_str(mode_), mode_str(m));
if (isClosed())
return;
if (m != mode_) {
if (m != None) {
TRACE("setMode: set flags");
watcher_.set(fd_, static_cast<int>(m));
if (!watcher_.is_active()) {
TRACE("setMode: start watcher");
watcher_.start();
}
} else {
TRACE("stop watcher and timer");
if (watcher_.is_active())
watcher_.stop();
if (timer_.is_active())
timer_.stop();
}
mode_ = m;
}
}
int cmp_type(alpm_pkg_t *pkg, const char *path,
struct archive_entry *entry, struct stat *st)
{
const char *type = mode_str(archive_entry_filetype(entry));
const char *ftype = mode_str(st->st_mode);
if(type != ftype) {
eprintf("%s: '%s' type mismatch (expected %s)\n",
alpm_pkg_get_name(pkg), path, type);
return 1;
}
return 0;
}
void show_file_info(char *filename, struct stat *info_p) /* 打印文件的相关信息 */
{
char modestr[11];
mode_str(info_p->st_mode, modestr);
if((strcmp(arr1,"-a") == 0) ||(strcmp(arr2,"-a") == 0))
{
printf("%s", modestr);
printf("%3d ", (int)info_p->st_nlink);
printf("%-8s", uid_str(info_p->st_uid));
printf("%-8s", gid_str(info_p->st_gid));
printf("%4ld ", (long)info_p->st_size);
printf("%.12s ", 4 + ctime(&info_p->st_mtime));
printf("%s\n", filename);
}else if(filename[0] != '.') //文件名第一个字符不为.就显示
{
printf("%s", modestr);
printf("%3d ", (int)info_p->st_nlink);
printf("%-8s", uid_str(info_p->st_uid));
printf("%-8s", gid_str(info_p->st_gid));
printf("%4ld ", (long)info_p->st_size);
printf("%.12s ", 4 + ctime(&info_p->st_mtime));
printf("%s\n", filename);
}
}
void Iss2::InstructionRequest::print( std::ostream &o ) const
{
o << "<InsReq "
<< " mode " << mode_str(mode)
<< (valid ? " valid" : " invalid")
<< " @ " << std::hex << std::showbase << addr
<< ">";
}
static const char *pr_grmode(struct lkb *lkb)
{
if (lkb->status == DLM_LKSTS_GRANTED || lkb->status == DLM_LKSTS_CONVERT)
return mode_str(lkb->grmode);
else if (lkb->status == DLM_LKSTS_WAITING || lkb->rsb_lookup)
return "--";
else
return "XX";
}
void Socket::inspect(Buffer& out)
{
// only complain about potential bugs...
out << "fd:" << fd_ << ", " << "timer:" << timer_.is_active() << "<br/>";
out << "io.ev:" << mode_str((Mode)watcher_.events) << ", "
<< "io.x0:" << mode_str(mode_) << "<br/>";
if (mode_ != watcher_.events) {
out << "<b>backend events differ from watcher mask</b><br/>";
}
struct stat st;
if (fstat(fd_, &st) < 0) {
out << "fd stat error: " << strerror(errno) << "<br/>";
}
}
void show_file_info(char *filename, struct stat *info_p)
{
char modestr[11];
mode_str(info_p->st_mode, modestr);
printf("%s", modestr);
printf("%3d ", (int)info_p->st_nlink);
printf("%-8s", uid_str(info_p->st_uid));
printf("%-8s", gid_str(info_p->st_gid));
printf("%4ld ", (long)info_p->st_size);
printf("%.12s ", 4 + ctime(&info_p->st_mtime));
printf("%s\n", filename);
}
void Iss2::DataRequest::print( std::ostream &o ) const
{
o << "<DataReq"
<< " mode " << mode_str(mode)
<< (valid ? " valid" : " invalid")
<< " type " << type_str(type);
if ( type == XTN_READ || type == XTN_WRITE )
//o << " (" << xtn_str((enum ExternalAccessType)addr) << ")";
o << " (" << xtn_str((enum ExternalAccessType)(addr/4)) << ")";
else
o << " @ " << std::hex << std::showbase << addr;
o << " wdata " << std::hex << std::showbase << wdata
<< " be " << std::hex << (int)be
<< ">";
}
void Socket::io(ev::io& /*io*/, int revents)
{
lastActivityAt_.update(ev_now(loop_));
TRACE("io(revents=0x%04X): mode=%s", revents, mode_str(mode_));
timer_.stop();
if (state_ == Connecting)
onConnectComplete();
else if (state_ == Handshake)
handshake(revents);
else if (callback_)
callback_(this, callbackData_, revents);
}
static const char *pr_rqmode(struct lkb *lkb)
{
static char buf[5];
memset(buf, 0, sizeof(buf));
if (lkb->status == DLM_LKSTS_GRANTED) {
return " ";
} else if (lkb->status == DLM_LKSTS_CONVERT ||
lkb->status == DLM_LKSTS_WAITING ||
lkb->rsb_lookup) {
sprintf(buf, "(%s)", mode_str(lkb->rqmode));
return buf;
} else {
return "(XX)";
}
}
int
list_dir_internal(stralloc* dir, char type) {
size_t l;
struct dir_s d;
stralloc pre;
int dtype;
int is_dir, is_symlink;
size_t len;
#if !WINDOWS_NATIVE
struct stat st;
static dev_t root_dev;
#endif
char *name, *s;
(void)type;
while(dir->len > 1 && IS_DIRSEP(dir->s[dir->len - 1])) dir->len--;
stralloc_nul(dir);
#if !WINDOWS_NATIVE
if(root_dev == 0) {
if(stat(dir->s, &st) != -1) {
root_dev = st.st_dev;
}
}
#endif
if(dir_open(&d, dir->s) != 0) {
buffer_puts(buffer_2, "ERROR: Opening directory ");
buffer_putsa(buffer_2, dir);
buffer_puts(buffer_2, " failed!\n");
buffer_flush(buffer_2);
goto end;
}
if(dir->s[dir->len - 1] != DIRSEP_C)
stralloc_cats(dir, DIRSEP_S);
l = dir->len;
while((name = dir_read(&d))) {
unsigned int mode = 0, nlink = 0, uid = 0, gid = 0;
uint64 size = 0, mtime = 0;
dtype = dir_type(&d);
dir->len = l;
if(str_equal(name, "") || str_equal(name, ".") || str_equal(name, "..")) {
continue;
}
stralloc_readyplus(dir, str_len(name) + 1);
str_copy(dir->s + dir->len, name);
dir->len += str_len(name);
is_symlink = !!(dtype & D_SYMLINK);
#if !WINDOWS_NATIVE
if(!opt_deref && lstat(dir->s, &st) != -1) {
if(root_dev && st.st_dev) {
if(st.st_dev != root_dev) {
continue;
}
}
}
#endif
#if !WINDOWS_NATIVE
if(S_ISLNK(st.st_mode)) {
stat(dir->s, &st);
}
mode = st.st_mode;
#endif
if(dtype) {
is_dir = !!(dtype & D_DIRECTORY);
} else {
#if WINDOWS_NATIVE
is_dir = 0;
#else
is_dir = !!S_ISDIR(mode);
#endif
}
if(dtype & D_SYMLINK)
is_symlink = 1;
#if !WINDOWS_NATIVE
nlink = st.st_nlink;
uid = st.st_uid;
gid = st.st_gid;
size = st.st_size;
mtime = st.st_mtime;
#else
mode = (is_dir ? 0040000 : 0100000) | (is_symlink ? 0120000 : 0);
#if USE_READDIR
if(!is_dir) {
size = dir_size(&d); /* dir_INTERNAL(&d)->dir_entry->d_name); */
mtime = dir_time(&d);
} else {
mtime = 0;
size = 0;
}
#else
size = dir_size(&d);
mtime = dir_time(&d, D_TIME_MODIFICATION);
#endif
#endif
if(opt_list && size >= opt_minsize) {
stralloc_init(&pre);
/* Mode string */
mode_str(&pre, mode);
stralloc_catb(&pre, " ", 1);
/* num links */
make_num(&pre, nlink, 3);
stralloc_catb(&pre, " ", 1);
/* uid */
make_num(&pre, uid, 0);
stralloc_catb(&pre, " ", 1);
/* gid */
make_num(&pre, gid, 0);
stralloc_catb(&pre, " ", 1);
/* size */
make_num(&pre, size, 6);
stralloc_catb(&pre, " ", 1);
/* time */
make_num(&pre, mtime, 0);
/* make_time(&pre, mtime, 10); */
stralloc_catb(&pre, " ", 1);
}
/* fprintf(stderr, "%d %08x\n", is_dir, dir_ATTRS(&d)); */
if(is_dir)
stralloc_catc(dir, opt_separator);
if(dir->len > MAX_PATH) {
buffer_puts(buffer_2, "ERROR: Directory ");
buffer_putsa(buffer_2, dir);
buffer_puts(buffer_2, " longer than MAX_PATH (" STRINGIFY(MAX_PATH) ")!\n");
/*buffer_putulong(buffer_2, MAX_PATH);
buffer_puts(buffer_2, ")!\n");*/
buffer_flush(buffer_2);
goto end;
}
s = dir->s;
len = dir->len;
if(len >= 2 && s[0] == '.' && IS_DIRSEP(s[1])) {
len -= 2;
s += 2;
}
if(opt_list && size >= opt_minsize)
buffer_putsa(buffer_1, &pre);
if(opt_relative_to) {
size_t sz = str_len(opt_relative_to);
if(str_diffn(s, opt_relative_to, sz) == 0) {
s += sz;
len -= sz;
while(*s == '\\' || *s == '/') {
s++;
len--;
}
}
}
if(size >= opt_minsize) {
buffer_put(buffer_1, s, len);
buffer_put(buffer_1, "\n", 1);
buffer_flush(buffer_1);
}
if(is_dir && (opt_deref || !is_symlink)) {
dir->len--;
list_dir_internal(dir, 0);
}
}
end:
dir_close(&d);
return 0;
}
static void do_lockdump(char *name)
{
FILE *file;
char path[PATH_MAX];
char line[LOCK_LINE_MAX];
char r_name[DLM_RESNAME_MAXLEN+1];
int r_nodeid;
int r_len;
int rv;
unsigned int tm;
unsigned long long xid;
uint32_t id;
int nodeid;
uint32_t remid;
int ownpid;
uint32_t exflags;
uint32_t flags;
int8_t status;
int8_t grmode;
int8_t rqmode;
snprintf(path, PATH_MAX, "/sys/kernel/debug/dlm/%s_locks", name);
file = fopen(path, "r");
if (!file) {
fprintf(stderr, "can't open %s: %s\n", path, strerror(errno));
return;
}
/* skip the header on the first line */
if (!fgets(line, LOCK_LINE_MAX, file))
return;
while (fgets(line, LOCK_LINE_MAX, file)) {
rv = sscanf(line, "%x %d %x %u %llu %x %x %hhd %hhd %hhd %u %d %d",
&id,
&nodeid,
&remid,
&ownpid,
&xid,
&exflags,
&flags,
&status,
&grmode,
&rqmode,
&tm,
&r_nodeid,
&r_len);
if (rv != 13) {
fprintf(stderr, "invalid debugfs line %d: %s\n",
rv, line);
return;
}
memset(r_name, 0, sizeof(r_name));
parse_r_name(line, r_name);
/* don't print MSTCPY locks without -M */
if (!r_nodeid && nodeid) {
if (!dump_mstcpy)
continue;
printf("id %08x gr %s rq %s pid %u MSTCPY %d \"%s\"\n",
id, mode_str(grmode), mode_str(rqmode),
ownpid, nodeid, r_name);
continue;
}
/* A hack because dlm-kernel doesn't set rqmode back to IV when
a NOQUEUE convert fails, which means in a lockdump it looks
like a granted lock is still converting since rqmode is not
IV. (does it make sense to include status in the output,
e.g. G,C,W?) */
if (status == DLM_LKSTS_GRANTED)
rqmode = LKM_IVMODE;
printf("id %08x gr %s rq %s pid %u master %d \"%s\"\n",
id, mode_str(grmode), mode_str(rqmode),
ownpid, nodeid, r_name);
}
fclose(file);
}
/*!
*/
std::string
gzfilebuf::makeModeString( std::ios_base::openmode mode,
int level,
int strategy )
{
std::string mode_str("");
mode_str.reserve( 6 );
// set I/O
bool testi = static_cast< bool >( mode & std::ios_base::in );
bool testo = static_cast< bool >( mode & std::ios_base::out );
if ( ( testi && testo )
|| ( ! testi && ! testo ) )
{
// invalid mode
return std::string( "" );
}
if ( testi )
{
// If input mode, it is not necessary to consider
// about compression level and strategy.
mode_str = "rb";
return mode_str;
}
if ( testo )
{
mode_str = "wb";
}
// set compression level
if ( level == DEFAULT_COMPRESSION )
{
// nothing to do
}
else if ( NO_COMPRESSION <= level
&& level <= BEST_COMPRESSION )
{
char lvstr[4];
snprintf( lvstr, 4, "%d", level );
mode_str += lvstr;
}
else
{
// invalid compression level
return std::string( "" );
}
// set strategy
switch ( strategy ) {
case DEFAULT_STRATEGY:
// nothing to do
break;
case FILTERED:
mode_str += "f";
break;
case HUFFMAN_ONLY:
mode_str += "h";
break;
case RLE:
mode_str += "R";
break;
default:
// why reach here?
break;
}
return mode_str;
}
