Exemplo n.º 1
0
Arquivo: ls2.c Projeto: Yokoloki/Books
void show_file_info(char *filename, struct stat *info_p){
    char *uid_to_name(), *ctime(), *gid_to_name(), *filemode();
    void mode_to_letters();
    char modestr[11];
    mode_to_letters(info_p->st_mode, modestr);
    printf("%s", modestr);
    printf(" %4d", (int)info_p->st_nlink);
    printf(" %-8s", uid_to_name(info_p->st_uid));
    printf(" %-8s", gid_to_name(info_p->st_gid));
    printf(" %8ld", (long)info_p->st_size);
    printf(" %.12s", ctime(&info_p->st_mtime)+4);
    printf(" %s\n", filename);
}
Exemplo n.º 2
0
static int print_inhibitors(sd_bus *bus, sd_bus_error *error) {
        _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
        const char *what, *who, *why, *mode;
        unsigned int uid, pid;
        unsigned n = 0;
        int r;

        r = sd_bus_call_method(
                        bus,
                        "org.freedesktop.login1",
                        "/org/freedesktop/login1",
                        "org.freedesktop.login1.Manager",
                        "ListInhibitors",
                        error,
                        &reply,
                        "");
        if (r < 0)
                return r;

        r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ssssuu)");
        if (r < 0)
                return bus_log_parse_error(r);

        while ((r = sd_bus_message_read(reply, "(ssssuu)", &what, &who, &why, &mode, &uid, &pid)) > 0) {
                _cleanup_free_ char *comm = NULL, *u = NULL;

                get_process_comm(pid, &comm);
                u = uid_to_name(uid);

                printf("     Who: %s (UID "UID_FMT"/%s, PID "PID_FMT"/%s)\n"
                       "    What: %s\n"
                       "     Why: %s\n"
                       "    Mode: %s\n\n",
                       who, uid, strna(u), pid, strna(comm),
                       what,
                       why,
                       mode);

                n++;
        }
        if (r < 0)
                return bus_log_parse_error(r);

        r = sd_bus_message_exit_container(reply);
        if (r < 0)
                return bus_log_parse_error(r);

        printf("%u inhibitors listed.\n", n);
        return 0;
}
Exemplo n.º 3
0
void show_file_info(char *filename,struct stat *info_p)
{
	char *uid_to_name(),*ctime(),*gid_to_name(),*filemode();
//	void mode_to_letters();
	char modestr[11];
	mode_to_letters(info_p->st_mode,modestr);
	printf("%s",modestr);
	printf("%3d ",(int)info_p->st_nlink);
	printf("%-5s",uid_to_name(info_p->st_uid));
	printf("%-5s",gid_to_name(info_p->st_gid));
	printf("%10ld ",(long)info_p->st_size);
	printf("%.14s",4+ctime(&info_p->st_mtime));
	printf(" %s\n",basename(filename));
}
Exemplo n.º 4
0
Arquivo: ls.c Projeto: iceout/uup
void show_file_info(char *fname, struct stat *info)
{
    char modestr[11];

    mode_to_letters(info->st_mode, modestr);
    
    printf("%s", modestr);
    printf(" %4d", (int)info->st_nlink);
	printf(" %-6s" , uid_to_name(info->st_uid) );
	printf(" %-6s" , gid_to_name(info->st_gid) );
	printf(" %8ld" , (long)info->st_size);
    printf(" %.12s", 4+ctime(&info->st_mtime));
    printf(" %s\n", fname);
}
Exemplo n.º 5
0
void show_file_info(const char *filename, struct stat *info_p)
{
    char modestr[11];

    mode_to_letters(info_p->st_mode, modestr);

    printf("%s", modestr);
    printf(" %2d", (int)info_p->st_nlink);
    printf(" %-5s", uid_to_name(info_p->st_uid));
    printf(" %-5s", gid_to_name(info_p->st_gid));
    printf(" %6ld", (long)info_p->st_size);
    printf(" %.12s", 4+ctime(&info_p->st_mtime));
    printf(" %s\n", filename);
}
Exemplo n.º 6
0
void show_file_info(char * filename, struct stat * statp)
{
    char *filemode(), *uid_to_name(), *gid_to_name(), *ctime();
    char modestr[11];

    mode_to_letter(statp->st_mode, modestr);

    printf("%s ", modestr);
    printf("%4d ", (int)statp->st_nlink);
    printf("%-8s ", uid_to_name(statp->st_uid));
    printf("%-8s ", gid_to_name(statp->st_gid));
    printf("%8ld ", (long)statp->st_size);
    printf("%.12s ", 4+ctime(&statp->st_mtime));
    printf("%s\n", filename);
}
Exemplo n.º 7
0
void show_file_info(char *filename, struct stat *info_p)
{
     char modestr[11];

     mode_to_letters(info_p->st_mode, modestr);

     printf("%s\t", modestr);
     printf("%4d\t", (int)info_p->st_nlink);
     printf("%-8s\t", uid_to_name(info_p->st_uid));
     printf("%-8s\t", gid_to_name(info_p->st_gid));
     printf("%8ld\t", (long)info_p->st_size);
     char * tim = ctime(&(info_p->st_mtim));
     printf("%.12s\t", 4 + ctime(&(info_p->st_mtim)));
     printf("%s\n", filename);
}
Exemplo n.º 8
0
void show_file_info(char *filename,struct stat *info_p,int maxlink,int maxsize)
/*
 * display the info about 'filename'.  The info is stored in struct at *info_p
 */
{
	char	*uid_to_name(short uid),*gid_to_name(short gid),*filemode(int mode);

    struct tm *mtime = gmtime(&info_p->st_mtime);
	printf("%s ",filemode(info_p->st_mode));
	printf("%*d ",maxlink,(int)info_p->st_nlink);	/* links */
	printf("%s ",uid_to_name(info_p->st_uid));
	printf("%s ",gid_to_name(info_p->st_gid));
	printf("%*ld ",maxsize,(long)info_p->st_size);	/* size  */
	printf("%d-%02d-%02d ",(mtime->tm_year) + 1900,(mtime->tm_mon) + 1,mtime->tm_mday);
	printf("%02d:%02d ",mtime->tm_hour + 8,mtime->tm_min);
	printf("%s \n",filename);			/* print name	 */
}
Exemplo n.º 9
0
static void			extract_l_info(t_l_info *info, t_filedir *filedir)
{
	unsigned int	temp;

	info->block_mem_total += filedir->stats->st_blocks;
	temp = digitc(filedir->stats->st_nlink);
	if (info->link_spacing < temp)
		info->link_spacing = temp;
	temp = ft_strlen(uid_to_name(filedir->stats->st_uid));
	if (info->user_spacing < temp)
		info->user_spacing = temp;
	temp = ft_strlen(gid_to_name(filedir->stats->st_gid));
	if (info->group_spacing < temp)
		info->group_spacing = temp;
	temp = ls_size_size(info, filedir->stats);
	if (info->size_spacing < temp)
		info->size_spacing = temp;
}
void show_file_info(char *filename, struct stat *info_p)
/*
 * display the info about filename. The info is stored in struct at *info_p
 * */
{
  char *uid_to_name(), *ctime(), *gid_to_name(), *filemode();
  void mode_to_letters();
  char modestr[11];

  mode_to_letters(info_p->st_mode, modestr);

  printf("%s", modestr);
  printf("%4d", (int)info_p->st_nlink);
  printf(" %-8s", uid_to_name(info_p->st_uid));
  printf(" %-8s", gid_to_name(info_p->st_gid));
  printf(" %8ld", (long)info_p->st_size);
  printf(" %.12s", 4+ctime(&info_p->st_mtime));
  printf(" %s\n", filename);
}
Exemplo n.º 11
0
Arquivo: ls2.c Projeto: acgtyrant/UULP
extern void show_stat_info(char *filename, struct stat *stat_buf_p) {
  char letters[10];
  mode_to_letters(stat_buf_p->st_mode, letters);
  printf("%s", letters);

  printf("%ld ", stat_buf_p->st_nlink);

  char *uid_name = uid_to_name(stat_buf_p->st_uid);
  printf("%-8s ", uid_name);

  char *gid_name = gid_to_name(stat_buf_p->st_gid);
  printf("%-8s ", gid_name);

  printf("%ld ", stat_buf_p->st_size);

  char *time_str = ctime(&(stat_buf_p->st_mtime)) + 4;
  printf("%.12s ", time_str);

  printf("%s ", filename);
  printf("\n");
}
void show_file_info(char* filename, struct stat * info_p)
{
	char	*uid_to_name(), *ctime(), *gid_to_name(), *filemode();
	void mode_to_letters();
	char modestr[11];
	char newFilename[20] = "./" ;
//	printf("run show file info\n");	

	mode_to_letters( info_p->st_mode, modestr );
	if( (strncmp(".", filename ,1) == 0 ) || ( strncmp("..", filename, 2) == 0 ))
	{
		return ;
	}
	
	printf(" %s " , modestr );
	printf(" %4d ", (int)info_p->st_nlink);
	printf(" %-8s ", uid_to_name(info_p->st_uid) );
	printf(" %-8s ", gid_to_name(info_p->st_gid) );
	printf(" %8ld ", (long)info_p->st_size );
	printf(" %.12s ", 4 + ctime(&info_p->st_mtime));
	printf(" %s\n", filename);	

	if ((strncmp ("d", modestr,1) == 0) && (flag == OPTION)  )
	{
		printf("\n  ++++++++++   Directory %s  ++++++++++ \n", filename);
//		strcat(filename,"/.");
		strcat(newFilename ,filename);
		printf("%s\n",newFilename);
		chdir(newFilename);
		do_ls(".");
		chdir("../");
		printf("\n  ++++++++++ Directory %s End  +++++++++ \n", filename);	

	}

}
Exemplo n.º 13
0
static int rename_service(sd_bus *a, sd_bus *b) {
        _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
        _cleanup_free_ char *p = NULL, *name = NULL;
        const char *comm;
        char **cmdline;
        uid_t uid;
        pid_t pid;
        int r;

        assert(a);
        assert(b);

        r = sd_bus_get_owner_creds(b, SD_BUS_CREDS_EUID|SD_BUS_CREDS_PID|SD_BUS_CREDS_CMDLINE|SD_BUS_CREDS_COMM|SD_BUS_CREDS_AUGMENT, &creds);
        if (r < 0)
                return r;

        r = sd_bus_creds_get_euid(creds, &uid);
        if (r < 0)
                return r;

        r = sd_bus_creds_get_pid(creds, &pid);
        if (r < 0)
                return r;

        r = sd_bus_creds_get_cmdline(creds, &cmdline);
        if (r < 0)
                return r;

        r = sd_bus_creds_get_comm(creds, &comm);
        if (r < 0)
                return r;

        name = uid_to_name(uid);
        if (!name)
                return -ENOMEM;

        p = strv_join(cmdline, " ");
        if (!p)
                return -ENOMEM;

        /* The status string gets the full command line ... */
        sd_notifyf(false,
                   "STATUS=Processing requests from client PID "PID_FMT" (%s); UID "UID_FMT" (%s)",
                   pid, p,
                   uid, name);

        /* ... and the argv line only the short comm */
        if (arg_command_line_buffer) {
                size_t m, w;

                m = strlen(arg_command_line_buffer);
                w = snprintf(arg_command_line_buffer, m,
                             "[PID "PID_FMT"/%s; UID "UID_FMT"/%s]",
                             pid, comm,
                             uid, name);

                if (m > w)
                        memzero(arg_command_line_buffer + w, m - w);
        }

        log_debug("Running on behalf of PID "PID_FMT" (%s), UID "UID_FMT" (%s), %s",
                  pid, p,
                  uid, name,
                  a->unique_name);

        return 0;
}
Exemplo n.º 14
0
int main(int argc, char *argv[])
{
	int i;
	gid_t user_gid;
	uid_t user_uid;


	int is_only_group = 0;
	int is_only_group_all = 0;
	int is_name = 0;
	int is_only_user = 0;
	int is_real = 0;

	//bug!: myid -Gn - err
	char *opts="rgGnu";
	int opt, opt_c = 0;
	while((opt=getopt(argc,argv,opts))!=-1){
		switch(opt){
			case 'a':
				break;
			case 'g':
				is_only_group = 1;
				break;
			case 'G':
				is_only_group_all = 1;
				break;
			case 'n':
				is_name = 1;
				break;
			case 'r':
				is_real = 1;
				break;
			case 'u':
				is_only_user = 1;
				break;
		}
		opt_c++;
	}
	//without username
	if(argc == 1 || (opt_c + 1) == argc){
		if( is_real){
			user_gid = getgid();
			user_uid = getuid();
		}
		else{
			user_gid = getegid();
			user_uid = geteuid();

		}
	}
	//with username in command line
	else{
		user_gid = name_to_uid(argv[1+opt_c]);
		user_uid = name_to_gid(argv[1+opt_c]); 
	}
	// -g flag.
	if( is_only_group){
		if( is_name)
			printf("%s\n",gid_to_name(user_gid));
		else
			printf("%d\n",user_gid);
		return 0;
	}
	// -G flag.
	if( is_only_group_all){
		int list_size = 0;
		gid_t * user_groups = get_groups(gid_to_name(user_gid),&list_size);
		for( i=0;i<list_size;i++)
			if( is_name)
				printf("%s ",gid_to_name(user_groups[i]));
			else
				printf("%d ",user_groups[i]);
		printf("\n");
		return 0;
	}
	// -u flag.
	if( is_only_user){
		if( is_name)
			printf("%s\n",uid_to_name(user_uid));
		else
			printf("%d\n",user_uid);
		return 0;
	}
	//wrong flags
	if( is_name && is_real){
		fprintf(stderr,"id: cannot print only names or real IDs in default format\n");
		return EARG;
	}
	//common case:
	printf("uid=%d(%s) ",user_uid,uid_to_name(user_uid));
	printf("gid=%d(%s) ",user_gid,gid_to_name(user_gid));

	int list_size = 0;
	gid_t * user_groups = get_groups(gid_to_name(user_gid),&list_size);
	printf("groups=");
	printf("%s(%d)",gid_to_name(user_gid),user_gid);
	for( i=0;i<list_size;i++)
		printf("%d(%s) ",	user_groups[i],
					gid_to_name(user_groups[i]));
	printf("\n");
	return 0;
}
Exemplo n.º 15
0
static void test_install_printf(void) {
        char    name[] = "name.service",
                path[] = "/run/systemd/system/name.service";
        UnitFileInstallInfo i = { .name = name, .path = path, };
        UnitFileInstallInfo i2 = { .name= name, .path = path, };
        char    name3[] = "*****@*****.**",
                path3[] = "/run/systemd/system/name.service";
        UnitFileInstallInfo i3 = { .name = name3, .path = path3, };
        UnitFileInstallInfo i4 = { .name = name3, .path = path3, };

        _cleanup_free_ char *mid = NULL, *bid = NULL, *host = NULL, *uid = NULL, *user = NULL;

        assert_se(specifier_machine_id('m', NULL, NULL, &mid) >= 0 && mid);
        assert_se(specifier_boot_id('b', NULL, NULL, &bid) >= 0 && bid);
        assert_se((host = gethostname_malloc()));
        assert_se((user = uid_to_name(getuid())));
        assert_se(asprintf(&uid, UID_FMT, getuid()) >= 0);

#define expect(src, pattern, result)                                    \
        do {                                                            \
                _cleanup_free_ char *t = NULL;                          \
                _cleanup_free_ char                                     \
                        *d1 = strdup(i.name),                           \
                        *d2 = strdup(i.path);                           \
                assert_se(install_full_printf(&src, pattern, &t) >= 0 || !result); \
                memzero(i.name, strlen(i.name));                        \
                memzero(i.path, strlen(i.path));                        \
                assert_se(d1 && d2);                                    \
                if (result) {                                           \
                        printf("%s\n", t);                              \
                        assert_se(streq(t, result));                    \
                } else assert_se(t == NULL);                            \
                strcpy(i.name, d1);                                     \
                strcpy(i.path, d2);                                     \
        } while (false)

        expect(i, "%n", "name.service");
        expect(i, "%N", "name");
        expect(i, "%p", "name");
        expect(i, "%i", "");
        expect(i, "%u", user);
        expect(i, "%U", uid);

        expect(i, "%m", mid);
        expect(i, "%b", bid);
        expect(i, "%H", host);

        expect(i2, "%u", user);
        expect(i2, "%U", uid);

        expect(i3, "%n", "*****@*****.**");
        expect(i3, "%N", "name@inst");
        expect(i3, "%p", "name");
        expect(i3, "%u", user);
        expect(i3, "%U", uid);

        expect(i3, "%m", mid);
        expect(i3, "%b", bid);
        expect(i3, "%H", host);

        expect(i4, "%u", user);
        expect(i4, "%U", uid);
}
Exemplo n.º 16
0
/*
 *	print_report() - output a record for the report request.
 */
static void
print_report(int rec, struct acctent *ac)
{
	char		buf[160];
	char 		*start_time;
	char	*cp;
	char	*cp1;

	if (once) {
		if (uptime_start) {
			start_time = ctime(&uptime_start);
		} else {
			start_time = "Unknown\n";
		}

		fprintf(stdout, "\n\n");
		fprintf(stdout, "SYSTEM BOOT TIME STARTING AT %s", start_time);
		fprintf(stdout, "For %s %s %s %s %s\n", cfg_sn->sysname,
			cfg_sn->nodename, cfg_sn->release, cfg_sn->version,
			cfg_sn->machine);
		fprintf(stdout, "Preserved Accounting Jobs (Jobs which are "
			"continued).\n");
		fprintf(stdout, "=========================================="
			"==========\n\n");
		fprintf(stdout, "      JOB ID          USERS      PROJECT ID   "
			"         STARTED\n");
		fprintf(stdout, "------------------    -----    -------------  "
			"------------------------\n");
		once = FALSE;
	}

	switch (rec) {

	case REC_EOP:
		/*
		 *	Report about this preserved process.
		 */
		if (ac->csa != NULL ) {
			jobid = ac->csa->ac_jid;
			sprintf(buf, "%#18llx ", jobid);

			user = ac->csa->ac_uid;
			cp = uid_to_name(user);
			if (cp[0] == '?') {
				sprintf(&buf[19], "%8d  ", user);
			} else {
				sprintf(&buf[19], "%8s  ", cp);
			}
			project = ac->csa->ac_prid;
			if ((cp = prid_to_name(project)) == NULL) {
				cp="Unknown";
			}
			sprintf(&buf[28], "%15s  ", cp);

			if (ac->csa->ac_btime < btime) {
				btime = ac->csa->ac_btime;
			}
			fprintf(stdout, "%s", buf);
		}
		if (btime < MAXTIME) {
			fprintf(stdout, " %24s", ctime(&btime));
		} else
			fprintf(stdout, "\n");
		break;

	case REC_JOB:
	    {
		struct acctsoj *soj;
		struct accteoj *eoj;
		soj = ac->soj;
		eoj = ac->eoj;

		if (soj != NULL) {
			user = soj->ac_uid;
			cp = uid_to_name(user);
			if (cp[0] == '?') {
				sprintf(buf, "%8d  ", user);
			} else {
				sprintf(buf, "%8s  ", cp);
			}
			if (soj->ac_type == AC_SOJ) {
			    fprintf(stdout, "%#18llx %8s    SOJ record   %s",
				soj->ac_jid, buf,
				ctime(&soj->ac_btime));
			} else {
			    fprintf(stdout, "%#18llx %8s    ROJ record   %s",
				soj->ac_jid, buf,
				ctime(&soj->ac_rstime));
			}
		} else if (eoj != NULL) {
			user = eoj->ac_uid;
			cp = uid_to_name(user);
			if (cp[0] == '?') {
				sprintf(buf, "%8d  ", user);
			} else {
				sprintf(buf, "%8s  ", cp);
			}
			fprintf(stdout, "%#18llx %8s    EOJ record   %s",
				eoj->ac_jid, buf,
				ctime(&eoj->ac_btime));
		}
		/* CFG records should only be associated with jid 0 */
		if ((ac->cfg != NULL) && (ac->csa != NULL)) {
			fprintf(stdout, "CFG rec_job with jid 0x%llx \n",
				ac->csa->ac_jid);
		}
	    }
	    break;

	case REC_WKMG:
	    {
		struct wkmgmtbs *wm;
		wm = ac->wmbs;

		user = wm->uid;
		cp = uid_to_name(user);
		if (cp[0] == '?') {
			sprintf(buf, "%8d  ", user);
		} else {
			sprintf(buf, "%8s  ", cp);
		}
		if (wm->jid == WM_NO_JID) {
                        fprintf(stdout, "No job id          %8s     ", buf);
			fprintf(stdout, "%s record   %s",
				wm->serv_provider, ctime(&wm->time));
                } else {
                        fprintf(stdout, "%#18llx %8s    %s record   %s",
                                wm->jid, buf, wm->serv_provider,
				ctime(&wm->time));
                }
	    }
	    break;

	default:
		acct_err(ACCT_ABORT,
		       _("An unknown record type (%4o) was found in the '%s' routine."),
			rec, "print_report()");

	}		/* end of switch(rec) */

	return;
}
Exemplo n.º 17
0
void show_stat_info_oneline(char *fname, struct stat *buf) {
    static char mode[255];
    mode_to_letters(buf->st_mode, mode);
    printf("%s %d %s %s %s\t%s %s\n", mode, buf->st_nlink, uid_to_name(buf->st_uid), gid_to_name(buf->st_gid), bytes_to_human(buf->st_size), show_time((int) buf->st_mtime), fname);
}
Exemplo n.º 18
0
/*
 *	print_wm_rec - print raw workload management requests.
 */
static void print_wm_rec(struct wkmgmtbs *wbuf)
{
	time_t	stime;

	Ndebug("   WKMG_REC: type(%d), uid(%d-%s), jid(0x%llx).\n",
	       wbuf->type, wbuf->uid, uid_to_name(wbuf->uid), wbuf->jid);

	Ndebug("   WKMG_REC: ash(0x%llx), prid(%lld-%s).\n",
	       wbuf->ash, wbuf->prid, prid_to_name(wbuf->prid));

	stime = wbuf->time;
	Ndebug("   WKMG_REC: reqid(%lld), arrayid(%d), time: %s",
	       wbuf->reqid, wbuf->arrayid, ctime(&stime));

	switch(wbuf->type) {

	case WM_INFO:
	{
		int	subtype = wbuf->subtype < 0 ? 0 : wbuf->subtype;

		Ndebug("   WM_INFO: subtype(%d - %s).\n", subtype,
		       Info_statname[subtype]);
	}
	break;

	case WM_RECV:
	{
		int	subtype = wbuf->subtype < 0 ? 0 : wbuf->subtype;

		Ndebug("   WM_RECV: subtype(%d - %s).\n", subtype,
		       Recv_statname[subtype]);
		Ndebug("   WM_RECV: machname(%s), reqname(%s), quename(%s), "
		       "qtype(%d)\n", wbuf->machname, wbuf->reqname,
		       wbuf->quename, wbuf->qtype);
	}
	break;

	case WM_INIT:
	{
		int	subtype = wbuf->subtype < 0 ? 0 : wbuf->subtype;

		Ndebug("   WM_INIT: subtype(%d - %s).\n", subtype,
		       Init_statname[subtype]);
		Ndebug("   WM_INIT: machname(%s), reqname(%s), quename(%s), "
		       "qtype(%d)\n", wbuf->machname, wbuf->reqname,
		       wbuf->quename, wbuf->qtype);
	}
	break;

	case WM_TERM:
	{
		int	subtype = wbuf->subtype < 0 ? 0 : wbuf->subtype;

		Ndebug("   WM_TERM: subtype(%d - %s).\n", subtype,
		       Term_statname[subtype]);
		Ndebug("   WM_TERM: machname(%s), reqname(%s), quename(%s), "
		       "qtype(%d)\n", wbuf->machname, wbuf->reqname,
		       wbuf->quename, wbuf->qtype);
		Ndebug("   WM_TERM: code(%lld), utime(%lld), stime(%lld)\n",
		       wbuf->code, wbuf->utime, wbuf->stime);
	}
	break;

	case WM_SPOOL:
	{
		int	subtype = wbuf->subtype < 0 ? 0 : wbuf->subtype;

		if (subtype == WM_SPOOL_INIT) {
			Ndebug("   WM_SPOOL: subtype(%d - %s).\n", subtype,
			       Init_statname[subtype]);
		} else {
			Ndebug("   WM_SPOOL: subtype(%d - %s).\n", subtype,
			       Term_statname[subtype]);
		}
		Ndebug("   WM_SPOOL: machname(%s), reqname(%s), quename(%s), "
		       "qtype(%d)\n", wbuf->machname, wbuf->reqname,
		       wbuf->quename, wbuf->qtype);
	}
	break;

	case WM_CON:
	{
		int	subtype;

		Ndebug("   WM_CON: machname(%s), reqname(%s), quename(%s), "
		       "qtype(%d)\n", wbuf->machname, wbuf->reqname,
		       wbuf->quename, wbuf->qtype);
		Ndebug("   WM_CON: code(%lld), utime(%lld), stime(%lld)\n",
		       wbuf->code, wbuf->utime, wbuf->stime);
		subtype = wbuf->subtype < 0 ? 0 : wbuf->subtype;
		Ndebug("   WM_CON: init_type(%d - %s).\n", wbuf->subtype,
		       Init_statname[subtype]);
		subtype = wbuf->term_subtype < 0 ? 0 : wbuf->term_subtype;
		Ndebug("   WM_CON: term_type(%d - %s).\n", wbuf->term_subtype,
		       Term_statname[subtype]);
		Ndebug("   WM_CON: qwtime(%lld)\n", wbuf->qwtime);
	}
	break;

	default:
		Ndebug(" Unknown workload management request type(%d)\n",
		       wbuf->type);

	}		/* end of switch(type) */

	return;
}
Exemplo n.º 19
0
static int print_inhibitors(DBusConnection *bus, DBusError *error) {
        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
        unsigned n = 0;
        DBusMessageIter iter, sub, sub2;
        int r;

        r = bus_method_call_with_reply(
                        bus,
                        "org.freedesktop.login1",
                        "/org/freedesktop/login1",
                        "org.freedesktop.login1.Manager",
                        "ListInhibitors",
                        &reply,
                        NULL,
                        DBUS_TYPE_INVALID);
        if (r < 0)
                return r;

        if (!dbus_message_iter_init(reply, &iter))
                return -ENOMEM;

        if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY)
                return -EIO;

        dbus_message_iter_recurse(&iter, &sub);
        while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
                const char *what, *who, *why, *mode;
                _cleanup_free_ char *comm = NULL, *u = NULL;
                dbus_uint32_t uid, pid;

                if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT)
                        return -EIO;

                dbus_message_iter_recurse(&sub, &sub2);

                if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &what, true) < 0 ||
                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &who, true) < 0 ||
                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &why, true) < 0 ||
                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &mode, true) < 0 ||
                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &uid, true) < 0 ||
                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &pid, false) < 0)
                        return -EIO;

                get_process_comm(pid, &comm);
                u = uid_to_name(uid);

                printf("     Who: %s (UID %lu/%s, PID %lu/%s)\n"
                       "    What: %s\n"
                       "     Why: %s\n"
                       "    Mode: %s\n\n",
                       who, (unsigned long) uid, strna(u), (unsigned long) pid, strna(comm),
                       what,
                       why,
                       mode);

                dbus_message_iter_next(&sub);

                n++;
        }

        printf("%u inhibitors listed.\n", n);
        return 0;
}
Exemplo n.º 20
0
/* Change the owner and/or group of the file specified by FTS and ENT
   to UID and/or GID as appropriate.
   If REQUIRED_UID is not -1, then skip files with any other user ID.
   If REQUIRED_GID is not -1, then skip files with any other group ID.
   CHOPT specifies additional options.
   Return true if successful.  */
static bool
change_file_owner (FTS *fts, FTSENT *ent,
                   uid_t uid, gid_t gid,
                   uid_t required_uid, gid_t required_gid,
                   struct Chown_option const *chopt)
{
    char const *file_full_name = ent->fts_path;
    char const *file = ent->fts_accpath;
    struct stat const *file_stats;
    struct stat stat_buf;
    bool ok = true;
    bool do_chown;
    bool symlink_changed = true;

    switch (ent->fts_info)
    {
    case FTS_D:
        if (chopt->recurse)
        {
            if (ROOT_DEV_INO_CHECK (chopt->root_dev_ino, ent->fts_statp))
            {
                /* This happens e.g., with "chown -R --preserve-root 0 /"
                   and with "chown -RH --preserve-root 0 symlink-to-root".  */
                ROOT_DEV_INO_WARN (file_full_name);
                /* Tell fts not to traverse into this hierarchy.  */
                fts_set (fts, ent, FTS_SKIP);
                /* Ensure that we do not process "/" on the second visit.  */
                ignore_value (fts_read (fts));
                return false;
            }
            return true;
        }
        break;

    case FTS_DP:
        if (! chopt->recurse)
            return true;
        break;

    case FTS_NS:
        /* For a top-level file or directory, this FTS_NS (stat failed)
           indicator is determined at the time of the initial fts_open call.
           With programs like chmod, chown, and chgrp, that modify
           permissions, it is possible that the file in question is
           accessible when control reaches this point.  So, if this is
           the first time we've seen the FTS_NS for this file, tell
           fts_read to stat it "again".  */
        if (ent->fts_level == 0 && ent->fts_number == 0)
        {
            ent->fts_number = 1;
            fts_set (fts, ent, FTS_AGAIN);
            return true;
        }
        if (! chopt->force_silent)
            error (0, ent->fts_errno, _("cannot access %s"),
                   quote (file_full_name));
        ok = false;
        break;

    case FTS_ERR:
        if (! chopt->force_silent)
            error (0, ent->fts_errno, "%s", quote (file_full_name));
        ok = false;
        break;

    case FTS_DNR:
        if (! chopt->force_silent)
            error (0, ent->fts_errno, _("cannot read directory %s"),
                   quote (file_full_name));
        ok = false;
        break;

    case FTS_DC:		/* directory that causes cycles */
        if (cycle_warning_required (fts, ent))
        {
            emit_cycle_warning (file_full_name);
            return false;
        }
        break;

    default:
        break;
    }

    if (!ok)
    {
        do_chown = false;
        file_stats = NULL;
    }
    else if (required_uid == (uid_t) -1 && required_gid == (gid_t) -1
             && chopt->verbosity == V_off
             && ! chopt->root_dev_ino
             && ! chopt->affect_symlink_referent)
    {
        do_chown = true;
        file_stats = ent->fts_statp;
    }
    else
    {
        file_stats = ent->fts_statp;

        /* If this is a symlink and we're dereferencing them,
           stat it to get info on the referent.  */
        if (chopt->affect_symlink_referent && S_ISLNK (file_stats->st_mode))
        {
            if (fstatat (fts->fts_cwd_fd, file, &stat_buf, 0) != 0)
            {
                if (! chopt->force_silent)
                    error (0, errno, _("cannot dereference %s"),
                           quote (file_full_name));
                ok = false;
            }

            file_stats = &stat_buf;
        }

        do_chown = (ok
                    && (required_uid == (uid_t) -1
                        || required_uid == file_stats->st_uid)
                    && (required_gid == (gid_t) -1
                        || required_gid == file_stats->st_gid));
    }

    /* This happens when chown -LR --preserve-root encounters a symlink-to-/.  */
    if (ok
            && FTSENT_IS_DIRECTORY (ent)
            && ROOT_DEV_INO_CHECK (chopt->root_dev_ino, file_stats))
    {
        ROOT_DEV_INO_WARN (file_full_name);
        return false;
    }

    if (do_chown)
    {
        if ( ! chopt->affect_symlink_referent)
        {
            ok = (lchownat (fts->fts_cwd_fd, file, uid, gid) == 0);

            /* Ignore any error due to lack of support; POSIX requires
               this behavior for top-level symbolic links with -h, and
               implies that it's required for all symbolic links.  */
            if (!ok && errno == EOPNOTSUPP)
            {
                ok = true;
                symlink_changed = false;
            }
        }
        else
        {
            /* If possible, avoid a race condition with --from=O:G and without the
               (-h) --no-dereference option.  If fts's stat call determined
               that the uid/gid of FILE matched the --from=O:G-selected
               owner and group IDs, blindly using chown(2) here could lead
               chown(1) or chgrp(1) mistakenly to dereference a *symlink*
               to an arbitrary file that an attacker had moved into the
               place of FILE during the window between the stat and
               chown(2) calls.  If FILE is a regular file or a directory
               that can be opened, this race condition can be avoided safely.  */

            enum RCH_status err
                = restricted_chown (fts->fts_cwd_fd, file, file_stats, uid, gid,
                                    required_uid, required_gid);
            switch (err)
            {
            case RC_ok:
                break;

            case RC_do_ordinary_chown:
                ok = (chownat (fts->fts_cwd_fd, file, uid, gid) == 0);
                break;

            case RC_error:
                ok = false;
                break;

            case RC_inode_changed:
            /* FIXME: give a diagnostic in this case?  */
            case RC_excluded:
                do_chown = false;
                ok = false;
                break;

            default:
                abort ();
            }
        }

        /* On some systems (e.g., GNU/Linux 2.4.x),
           the chown function resets the `special' permission bits.
           Do *not* restore those bits;  doing so would open a window in
           which a malicious user, M, could subvert a chown command run
           by some other user and operating on files in a directory
           where M has write access.  */

        if (do_chown && !ok && ! chopt->force_silent)
            error (0, errno, (uid != (uid_t) -1
                              ? _("changing ownership of %s")
                              : _("changing group of %s")),
                   quote (file_full_name));
    }

    if (chopt->verbosity != V_off)
    {
        bool changed =
            ((do_chown && ok && symlink_changed)
             && ! ((uid == (uid_t) -1 || uid == file_stats->st_uid)
                   && (gid == (gid_t) -1 || gid == file_stats->st_gid)));

        if (changed || chopt->verbosity == V_high)
        {
            enum Change_status ch_status =
                (!ok ? CH_FAILED
                 : !symlink_changed ? CH_NOT_APPLIED
                 : !changed ? CH_NO_CHANGE_REQUESTED
                 : CH_SUCCEEDED);
            char *old_usr = file_stats ? uid_to_name (file_stats->st_uid) : NULL;
            char *old_grp = file_stats ? gid_to_name (file_stats->st_gid) : NULL;
            describe_change (file_full_name, ch_status,
                             old_usr, old_grp,
                             chopt->user_name, chopt->group_name);
            free (old_usr);
            free (old_grp);
        }
    }

    if ( ! chopt->recurse)
        fts_set (fts, ent, FTS_SKIP);

    return ok;
}
Exemplo n.º 21
0
int main (int argc, char *argv[]) 
{
	if( argc != 2 && argc != 1){
		printf("usage: %s dir\n", argv[0]);
		return 1;
	}

	DIR * dir;
	if(argc == 1){
		if (! (dir = opendir( ".")) ){
			perror("can't open dir\n");
			return 2;
		}
	}
	else{
		if (! (dir = opendir( argv[1])) ){
			perror("can't open dir\n");
			return 2;
		}
	}

	struct dirent *ds;
	struct stat ss;
	char path[BUF];
	char cur_path[BUF];
	char stime[BUF];
	char link_path[BUF];

	if( argc == 1)
		strcpy ( path, "");
	if( argc == 2)
		strcpy ( path, argv[1]);
	//printf("path = %s\n", path);

	while(1) {
		ds = readdir( dir);
		if( !ds )
			break;

		int is_link = 0;
		if( ds->d_type == D_TYPE_LINK )
			is_link = 1;
		strcpy ( cur_path, path);
		strcat ( cur_path, ds->d_name );
		//printf("cur_path = %s\n", cur_path);
		if (stat(cur_path, &ss) == -1) {
               		perror("stat");
               		return 1;
           	}
		if( !is_link ){
			switch (ss.st_mode & S_IFMT) {
				case S_IFBLK:  printf("b");            break;
				case S_IFCHR:  printf("c");        break;
				case S_IFDIR:  printf("d");               break;
				case S_IFIFO:  printf("p");               break;
				case S_IFLNK:  printf("l"); is_link = 1;              break;
				case S_IFREG:  printf("-");            break;
				case S_IFSOCK: printf("s");                  break;
				default:       printf("?");                break;
			}
		}
		else{
			printf("l");
		}
		//printf ( "mode = %o \n", ss.st_mode );
		int i, m, s;
		//here we print rights =)
		for( m = 0700, s = 06; s >= 0; m >>= 3, s -= 3 ){
			i = ss.st_mode & m;
			i >>= s;
			if(i & 04) printf("r");
			else printf("-");
			if(i & 02) printf("w");
			else printf("-");
			if(i & 01) printf("x");
			else printf("-");
		}		

		printf(" %3d", (int)ss.st_nlink);
		printf(" %10s %10s", uid_to_name(ss.st_uid), gid_to_name(ss.st_gid));
		printf(" %8d", (int)ss.st_size);
		strcpy ( stime, ctime(&ss.st_atime));  
		stime[strlen(stime)-2] = 0; // delete \n
		printf(" %s",stime);
		printf (" %s", ds->d_name);
		if( is_link ) {
			int readln = readlink ( cur_path, link_path, BUF);
			link_path[readln] = 0;
			printf(" -> %s", link_path);
		}
		printf("\n");
	}
	
	return 0;
}