ANSI C
- » Variable handling
- » Miscellaneous
- » POSIX
- » Date/Time
- » Math
- » Strings
- » PCRE
- » Arrays
- » Classes
- » Program execution
- » Directories
- » Filesystem
- » Memory
- » GD
- » Network
- » menu_code_ansiccode_socket
PERL
PHP
JavaScript

CONTENT

CHANGES

Szukaj

#top POSIX¶

[<<]|[<]|[^]|[v]|[>]|[>>]|[Zwiń]|[#top]|[X]

code / ansic / POSIX

#top Makefile¶

Dla ułatwienia korzystania z przykładów został utworzony jeden zbiorczy plik Makefile kompilujący przykłady użycia poniżej wymienionych funkcji dostępnych w systemach zgodnych ze specyfikacją POSIX.

Poniższe pliki Makefile zakładają obecność wszystkich plików przykładów, w przypadku chęci kompilacji za pomocą Makefile tylko wybranego przykładu należy zakomentować w pliku Makefile ostatnią pozycję zawierającą listę wszystkich targetów do wykonania make: $(ENDGRENT) ..., a następnie odkomentować powyżej komendę make zawierającą nazwę targetu dla bieżącego przykładu, np: w przypadku chęci kompilacji tylko przykładu endgrent należy zakomentować ostatnią pozycję rozpoczynającą się od make: $(ENDGRENT) ... (wstawić na początku przed make znak #), a następnie odkomentować pozycję: #make: $(ENDGRENT) (usunąć znak #).

#top Makefile (linux)¶

SELECT ALL

# Project: Project
# Makefile created

GCC         = gcc
INCS        = -DHAVE_ENDUSERSHELL=1 -DHAVE_SETLOGIN=1 -DHAVE_GETPGRP_0ARGS=1 -DHAVE_SETPGRP_0ARGS=1 -DHAVE_GETLOADAVG=1 -DHAVE_GETPASS=1 -DHAVE_GETUSERSHELL=1 -DHAVE_SETUSERSHELL=1 -DHAVE_GETPGID=1 -DHAVE_SETPGID=1 -DHAVE_TTYSLOT=1
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing -Wno-long-long -D_FILE_OFFSET_BITS=64 -D_LINUX -D_REENTRANT
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing
LIBS        =
LIBDIRS     =
LDFLAGS     = $(LIBDIRS) $(LIBS)
RM          = rm -f
MKDIR       = mkdir -p

ENDGRENT    = endgrent
ENDPWENT    = endpwent
ENDUSERSHELL= endusershell
GETEGID     = getegid
GETEUID     = geteuid
GETGID      = getgid
GETGRENT    = getgrent
GETGRGID    = getgrgid
GETGRNAM    = getgrnam
GETLOADAVG  = getloadavg
GETLOGIN    = getlogin
GETPASS     = getpass
GETPGID     = getpgid
GETPGRP     = getpgrp
GETPID      = getpid
GETPPID     = getppid
GETPWENT    = getpwent
GETPWNAM    = getpwnam
GETPWUID    = getpwuid
GETSID      = getsid
GETUID      = getuid
GETUSERSHELL= getusershell
ISATTY      = isatty
SETEGID     = setegid
SETEUID     = seteuid
SETGID      = setgid
SETGRENT    = setgrent
SETLOGIN    = setlogin
SETPGID     = setpgid
SETPGRP     = setpgrp
SETPWENT    = setpwent
SETSID      = setsid
SETUID      = setuid
SETUSERSHELL= setusershell
TTYNAME     = ttyname
TTYSLOT     = ttyslot
UNAME       = uname



all: objdir make

objdir:
	$(MKDIR) obj/

clean: objdir
	$(RM) obj/*.o *.o *~

#make: $(ENDGRENT)
#make: $(ENDPWENT)
#make: $(ENDUSERSHELL)
#make: $(GETEGID)
#make: $(GETEUID)
#make: $(GETGID)
#make: $(GETGRENT)
#make: $(GETGRGID)
#make: $(GETGRNAM)
#make: $(GETLOADAVG)
#make: $(GETLOGIN)
#make: $(GETPASS)
#make: $(GETPGID)
#make: $(GETPGRP)
#make: $(GETPID)
#make: $(GETPPID)
#make: $(GETPWENT)
#make: $(GETPWNAM)
#make: $(GETPWUID)
#make: $(GETSID)
#make: $(GETUID)
#make: $(GETUSERSHELL)
#make: $(ISATTY)
#make: $(SETEGID)
#make: $(SETEUID)
#make: $(SETGID)
#make: $(SETGRENT)
#make: $(SETLOGIN)
#make: $(SETPGID)
#make: $(SETPGRP)
#make: $(SETPWENT)
#make: $(SETSID)
#make: $(SETUID)
#make: $(SETUSERSHELL)
#make: $(TTYNAME)
#make: $(TTYSLOT)
#make: $(UNAME)
make: $(ENDGRENT) $(ENDPWENT) $(ENDUSERSHELL) $(GETEGID) $(GETEUID) $(GETGID) $(GETGRENT) $(GETGRGID) $(GETGRNAM) $(GETLOADAVG) $(GETLOGIN) $(GETPASS) $(GETPGID) $(GETPGRP) $(GETPID) $(GETPPID) $(GETPWENT) $(GETPWNAM) $(GETPWUID) $(GETSID) $(GETUID) $(GETUSERSHELL) $(ISATTY) $(SETEGID) $(SETEUID) $(SETGID) $(SETGRENT) $(SETLOGIN) $(SETPGID) $(SETPGRP) $(SETPWENT) $(SETSID) $(SETUID) $(SETUSERSHELL) $(TTYNAME) $(TTYSLOT) $(UNAME)



$(ENDGRENT): $(ENDGRENT).o
	$(GCC) -o $(ENDGRENT) obj/$(ENDGRENT).o $(LDFLAGS)
$(ENDGRENT).o:
	$(GCC) -o obj/$(ENDGRENT).o -c $(ENDGRENT).c $(CFLAGS)

$(ENDPWENT): $(ENDPWENT).o
	$(GCC) -o $(ENDPWENT) obj/$(ENDPWENT).o $(LDFLAGS)
$(ENDPWENT).o:
	$(GCC) -o obj/$(ENDPWENT).o -c $(ENDPWENT).c $(CFLAGS)

$(ENDUSERSHELL): $(ENDUSERSHELL).o
	$(GCC) -o $(ENDUSERSHELL) obj/$(ENDUSERSHELL).o $(LDFLAGS)
$(ENDUSERSHELL).o:
	$(GCC) -o obj/$(ENDUSERSHELL).o -c $(ENDUSERSHELL).c $(CFLAGS)

$(GETEGID): $(GETEGID).o
	$(GCC) -o $(GETEGID) obj/$(GETEGID).o $(LDFLAGS)
$(GETEGID).o:
	$(GCC) -o obj/$(GETEGID).o -c $(GETEGID).c $(CFLAGS)

$(GETEUID): $(GETEUID).o
	$(GCC) -o $(GETEUID) obj/$(GETEUID).o $(LDFLAGS)
$(GETEUID).o:
	$(GCC) -o obj/$(GETEUID).o -c $(GETEUID).c $(CFLAGS)

$(GETGID): $(GETGID).o
	$(GCC) -o $(GETGID) obj/$(GETGID).o $(LDFLAGS)
$(GETGID).o:
	$(GCC) -o obj/$(GETGID).o -c $(GETGID).c $(CFLAGS)

$(GETGRENT): $(GETGRENT).o
	$(GCC) -o $(GETGRENT) obj/$(GETGRENT).o $(LDFLAGS)
$(GETGRENT).o:
	$(GCC) -o obj/$(GETGRENT).o -c $(GETGRENT).c $(CFLAGS)

$(GETGRGID): $(GETGRGID).o
	$(GCC) -o $(GETGRGID) obj/$(GETGRGID).o $(LDFLAGS)
$(GETGRGID).o:
	$(GCC) -o obj/$(GETGRGID).o -c $(GETGRGID).c $(CFLAGS)

$(GETGRNAM): $(GETGRNAM).o
	$(GCC) -o $(GETGRNAM) obj/$(GETGRNAM).o $(LDFLAGS)
$(GETGRNAM).o:
	$(GCC) -o obj/$(GETGRNAM).o -c $(GETGRNAM).c $(CFLAGS)

$(GETLOADAVG): $(GETLOADAVG).o
	$(GCC) -o $(GETLOADAVG) obj/$(GETLOADAVG).o $(LDFLAGS)
$(GETLOADAVG).o:
	$(GCC) -o obj/$(GETLOADAVG).o -c $(GETLOADAVG).c $(CFLAGS)

$(GETLOGIN): $(GETLOGIN).o
	$(GCC) -o $(GETLOGIN) obj/$(GETLOGIN).o $(LDFLAGS)
$(GETLOGIN).o:
	$(GCC) -o obj/$(GETLOGIN).o -c $(GETLOGIN).c $(CFLAGS)

$(GETPASS): $(GETPASS).o
	$(GCC) -o $(GETPASS) obj/$(GETPASS).o $(LDFLAGS)
$(GETPASS).o:
	$(GCC) -o obj/$(GETPASS).o -c $(GETPASS).c $(CFLAGS)

$(GETPGID): $(GETPGID).o
	$(GCC) -o $(GETPGID) obj/$(GETPGID).o $(LDFLAGS)
$(GETPGID).o:
	$(GCC) -o obj/$(GETPGID).o -c $(GETPGID).c $(CFLAGS)

$(GETPGRP): $(GETPGRP).o
	$(GCC) -o $(GETPGRP) obj/$(GETPGRP).o $(LDFLAGS)
$(GETPGRP).o:
	$(GCC) -o obj/$(GETPGRP).o -c $(GETPGRP).c $(CFLAGS)

$(GETPID): $(GETPID).o
	$(GCC) -o $(GETPID) obj/$(GETPID).o $(LDFLAGS)
$(GETPID).o:
	$(GCC) -o obj/$(GETPID).o -c $(GETPID).c $(CFLAGS)

$(GETPPID): $(GETPPID).o
	$(GCC) -o $(GETPPID) obj/$(GETPPID).o $(LDFLAGS)
$(GETPPID).o:
	$(GCC) -o obj/$(GETPPID).o -c $(GETPPID).c $(CFLAGS)

$(GETPWENT): $(GETPWENT).o
	$(GCC) -o $(GETPWENT) obj/$(GETPWENT).o $(LDFLAGS)
$(GETPWENT).o:
	$(GCC) -o obj/$(GETPWENT).o -c $(GETPWENT).c $(CFLAGS)

$(GETPWNAM): $(GETPWNAM).o
	$(GCC) -o $(GETPWNAM) obj/$(GETPWNAM).o $(LDFLAGS)
$(GETPWNAM).o:
	$(GCC) -o obj/$(GETPWNAM).o -c $(GETPWNAM).c $(CFLAGS)

$(GETPWUID): $(GETPWUID).o
	$(GCC) -o $(GETPWUID) obj/$(GETPWUID).o $(LDFLAGS)
$(GETPWUID).o:
	$(GCC) -o obj/$(GETPWUID).o -c $(GETPWUID).c $(CFLAGS)

$(GETSID): $(GETSID).o
	$(GCC) -o $(GETSID) obj/$(GETSID).o $(LDFLAGS)
$(GETSID).o:
	$(GCC) -o obj/$(GETSID).o -c $(GETSID).c $(CFLAGS)

$(GETUID): $(GETUID).o
	$(GCC) -o $(GETUID) obj/$(GETUID).o $(LDFLAGS)
$(GETUID).o:
	$(GCC) -o obj/$(GETUID).o -c $(GETUID).c $(CFLAGS)

$(GETUSERSHELL): $(GETUSERSHELL).o
	$(GCC) -o $(GETUSERSHELL) obj/$(GETUSERSHELL).o $(LDFLAGS)
$(GETUSERSHELL).o:
	$(GCC) -o obj/$(GETUSERSHELL).o -c $(GETUSERSHELL).c $(CFLAGS)

$(ISATTY): $(ISATTY).o
	$(GCC) -o $(ISATTY) obj/$(ISATTY).o $(LDFLAGS)
$(ISATTY).o:
	$(GCC) -o obj/$(ISATTY).o -c $(ISATTY).c $(CFLAGS)

$(SETEGID): $(SETEGID).o
	$(GCC) -o $(SETEGID) obj/$(SETEGID).o $(LDFLAGS)
$(SETEGID).o:
	$(GCC) -o obj/$(SETEGID).o -c $(SETEGID).c $(CFLAGS)

$(SETEUID): $(SETEUID).o
	$(GCC) -o $(SETEUID) obj/$(SETEUID).o $(LDFLAGS)
$(SETEUID).o:
	$(GCC) -o obj/$(SETEUID).o -c $(SETEUID).c $(CFLAGS)

$(SETGID): $(SETGID).o
	$(GCC) -o $(SETGID) obj/$(SETGID).o $(LDFLAGS)
$(SETGID).o:
	$(GCC) -o obj/$(SETGID).o -c $(SETGID).c $(CFLAGS)

$(SETGRENT): $(SETGRENT).o
	$(GCC) -o $(SETGRENT) obj/$(SETGRENT).o $(LDFLAGS)
$(SETGRENT).o:
	$(GCC) -o obj/$(SETGRENT).o -c $(SETGRENT).c $(CFLAGS)

$(SETLOGIN): $(SETLOGIN).o
	$(GCC) -o $(SETLOGIN) obj/$(SETLOGIN).o $(LDFLAGS)
$(SETLOGIN).o:
	$(GCC) -o obj/$(SETLOGIN).o -c $(SETLOGIN).c $(CFLAGS)

$(SETPGID): $(SETPGID).o
	$(GCC) -o $(SETPGID) obj/$(SETPGID).o $(LDFLAGS)
$(SETPGID).o:
	$(GCC) -o obj/$(SETPGID).o -c $(SETPGID).c $(CFLAGS)

$(SETPGRP): $(SETPGRP).o
	$(GCC) -o $(SETPGRP) obj/$(SETPGRP).o $(LDFLAGS)
$(SETPGRP).o:
	$(GCC) -o obj/$(SETPGRP).o -c $(SETPGRP).c $(CFLAGS)

$(SETPWENT): $(SETPWENT).o
	$(GCC) -o $(SETPWENT) obj/$(SETPWENT).o $(LDFLAGS)
$(SETPWENT).o:
	$(GCC) -o obj/$(SETPWENT).o -c $(SETPWENT).c $(CFLAGS)

$(SETSID): $(SETSID).o
	$(GCC) -o $(SETSID) obj/$(SETSID).o $(LDFLAGS)
$(SETSID).o:
	$(GCC) -o obj/$(SETSID).o -c $(SETSID).c $(CFLAGS)

$(SETUID): $(SETUID).o
	$(GCC) -o $(SETUID) obj/$(SETUID).o $(LDFLAGS)
$(SETUID).o:
	$(GCC) -o obj/$(SETUID).o -c $(SETUID).c $(CFLAGS)

$(SETUSERSHELL): $(SETUSERSHELL).o
	$(GCC) -o $(SETUSERSHELL) obj/$(SETUSERSHELL).o $(LDFLAGS)
$(SETUSERSHELL).o:
	$(GCC) -o obj/$(SETUSERSHELL).o -c $(SETUSERSHELL).c $(CFLAGS)

$(TTYNAME): $(TTYNAME).o
	$(GCC) -o $(TTYNAME) obj/$(TTYNAME).o $(LDFLAGS)
$(TTYNAME).o:
	$(GCC) -o obj/$(TTYNAME).o -c $(TTYNAME).c $(CFLAGS)

$(TTYSLOT): $(TTYSLOT).o
	$(GCC) -o $(TTYSLOT) obj/$(TTYSLOT).o $(LDFLAGS)
$(TTYSLOT).o:
	$(GCC) -o obj/$(TTYSLOT).o -c $(TTYSLOT).c $(CFLAGS)

$(UNAME): $(UNAME).o
	$(GCC) -o $(UNAME) obj/$(UNAME).o $(LDFLAGS)
$(UNAME).o:
	$(GCC) -o obj/$(UNAME).o -c $(UNAME).c $(CFLAGS)

#top Makefile.obsd¶

SELECT ALL

# Project: Project
# Makefile created

GCC         = gcc
INCS        = -DHAVE_ENDUSERSHELL=1 -DHAVE_SETLOGIN=1 -DHAVE_GETPGRP_2ARGS=1 -DHAVE_SETPGRP_2ARGS=1 -DHAVE_GETLOADAVG=1 -DHAVE_GETPASS=1 -DHAVE_GETUSERSHELL=1 -DHAVE_SETUSERSHELL=1 -DHAVE_GETPGID=1 -DHAVE_SETPGID=1 -DHAVE_TTYSLOT=1
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing -Wno-long-long -D_FILE_OFFSET_BITS=64 -D_LINUX -D_REENTRANT
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing
LIBS        =
LIBDIRS     =
LDFLAGS     = $(LIBDIRS) $(LIBS)
RM          = rm -f
MKDIR       = mkdir -p

ENDGRENT    = endgrent
ENDPWENT    = endpwent
ENDUSERSHELL= endusershell
GETEGID     = getegid
GETEUID     = geteuid
GETGID      = getgid
GETGRENT    = getgrent
GETGRGID    = getgrgid
GETGRNAM    = getgrnam
GETLOADAVG  = getloadavg
GETLOGIN    = getlogin
GETPASS     = getpass
GETPGID     = getpgid
GETPGRP     = getpgrp
GETPID      = getpid
GETPPID     = getppid
GETPWENT    = getpwent
GETPWNAM    = getpwnam
GETPWUID    = getpwuid
GETSID      = getsid
GETUID      = getuid
GETUSERSHELL= getusershell
ISATTY      = isatty
SETEGID     = setegid
SETEUID     = seteuid
SETGID      = setgid
SETGRENT    = setgrent
SETLOGIN    = setlogin
SETPGID     = setpgid
SETPGRP     = setpgrp
SETPWENT    = setpwent
SETSID      = setsid
SETUID      = setuid
SETUSERSHELL= setusershell
TTYNAME     = ttyname
TTYSLOT     = ttyslot
UNAME       = uname



all: objdir make

objdir:
	$(MKDIR) obj/

clean: objdir
	$(RM) obj/*.o *.o *~

#make: $(ENDGRENT)
#make: $(ENDPWENT)
#make: $(ENDUSERSHELL)
#make: $(GETEGID)
#make: $(GETEUID)
#make: $(GETGID)
#make: $(GETGRENT)
#make: $(GETGRGID)
#make: $(GETGRNAM)
#make: $(GETLOADAVG)
#make: $(GETLOGIN)
#make: $(GETPASS)
#make: $(GETPGID)
#make: $(GETPGRP)
#make: $(GETPID)
#make: $(GETPPID)
#make: $(GETPWENT)
#make: $(GETPWNAM)
#make: $(GETPWUID)
#make: $(GETSID)
#make: $(GETUID)
#make: $(GETUSERSHELL)
#make: $(ISATTY)
#make: $(SETEGID)
#make: $(SETEUID)
#make: $(SETGID)
#make: $(SETGRENT)
#make: $(SETLOGIN)
#make: $(SETPGID)
#make: $(SETPGRP)
#make: $(SETPWENT)
#make: $(SETSID)
#make: $(SETUID)
#make: $(SETUSERSHELL)
#make: $(TTYNAME)
#make: $(TTYSLOT)
#make: $(UNAME)
make: $(ENDGRENT) $(ENDPWENT) $(ENDUSERSHELL) $(GETEGID) $(GETEUID) $(GETGID) $(GETGRENT) $(GETGRGID) $(GETGRNAM) $(GETLOADAVG) $(GETLOGIN) $(GETPASS) $(GETPGID) $(GETPGRP) $(GETPID) $(GETPPID) $(GETPWENT) $(GETPWNAM) $(GETPWUID) $(GETSID) $(GETUID) $(GETUSERSHELL) $(ISATTY) $(SETEGID) $(SETEUID) $(SETGID) $(SETGRENT) $(SETLOGIN) $(SETPGID) $(SETPGRP) $(SETPWENT) $(SETSID) $(SETUID) $(SETUSERSHELL) $(TTYNAME) $(TTYSLOT) $(UNAME)



$(ENDGRENT): $(ENDGRENT).o
	$(GCC) -o $(ENDGRENT) obj/$(ENDGRENT).o $(LDFLAGS)
$(ENDGRENT).o:
	$(GCC) -o obj/$(ENDGRENT).o -c $(ENDGRENT).c $(CFLAGS)

$(ENDPWENT): $(ENDPWENT).o
	$(GCC) -o $(ENDPWENT) obj/$(ENDPWENT).o $(LDFLAGS)
$(ENDPWENT).o:
	$(GCC) -o obj/$(ENDPWENT).o -c $(ENDPWENT).c $(CFLAGS)

$(ENDUSERSHELL): $(ENDUSERSHELL).o
	$(GCC) -o $(ENDUSERSHELL) obj/$(ENDUSERSHELL).o $(LDFLAGS)
$(ENDUSERSHELL).o:
	$(GCC) -o obj/$(ENDUSERSHELL).o -c $(ENDUSERSHELL).c $(CFLAGS)

$(GETEGID): $(GETEGID).o
	$(GCC) -o $(GETEGID) obj/$(GETEGID).o $(LDFLAGS)
$(GETEGID).o:
	$(GCC) -o obj/$(GETEGID).o -c $(GETEGID).c $(CFLAGS)

$(GETEUID): $(GETEUID).o
	$(GCC) -o $(GETEUID) obj/$(GETEUID).o $(LDFLAGS)
$(GETEUID).o:
	$(GCC) -o obj/$(GETEUID).o -c $(GETEUID).c $(CFLAGS)

$(GETGID): $(GETGID).o
	$(GCC) -o $(GETGID) obj/$(GETGID).o $(LDFLAGS)
$(GETGID).o:
	$(GCC) -o obj/$(GETGID).o -c $(GETGID).c $(CFLAGS)

$(GETGRENT): $(GETGRENT).o
	$(GCC) -o $(GETGRENT) obj/$(GETGRENT).o $(LDFLAGS)
$(GETGRENT).o:
	$(GCC) -o obj/$(GETGRENT).o -c $(GETGRENT).c $(CFLAGS)

$(GETGRGID): $(GETGRGID).o
	$(GCC) -o $(GETGRGID) obj/$(GETGRGID).o $(LDFLAGS)
$(GETGRGID).o:
	$(GCC) -o obj/$(GETGRGID).o -c $(GETGRGID).c $(CFLAGS)

$(GETGRNAM): $(GETGRNAM).o
	$(GCC) -o $(GETGRNAM) obj/$(GETGRNAM).o $(LDFLAGS)
$(GETGRNAM).o:
	$(GCC) -o obj/$(GETGRNAM).o -c $(GETGRNAM).c $(CFLAGS)

$(GETLOADAVG): $(GETLOADAVG).o
	$(GCC) -o $(GETLOADAVG) obj/$(GETLOADAVG).o $(LDFLAGS)
$(GETLOADAVG).o:
	$(GCC) -o obj/$(GETLOADAVG).o -c $(GETLOADAVG).c $(CFLAGS)

$(GETLOGIN): $(GETLOGIN).o
	$(GCC) -o $(GETLOGIN) obj/$(GETLOGIN).o $(LDFLAGS)
$(GETLOGIN).o:
	$(GCC) -o obj/$(GETLOGIN).o -c $(GETLOGIN).c $(CFLAGS)

$(GETPASS): $(GETPASS).o
	$(GCC) -o $(GETPASS) obj/$(GETPASS).o $(LDFLAGS)
$(GETPASS).o:
	$(GCC) -o obj/$(GETPASS).o -c $(GETPASS).c $(CFLAGS)

$(GETPGID): $(GETPGID).o
	$(GCC) -o $(GETPGID) obj/$(GETPGID).o $(LDFLAGS)
$(GETPGID).o:
	$(GCC) -o obj/$(GETPGID).o -c $(GETPGID).c $(CFLAGS)

$(GETPGRP): $(GETPGRP).o
	$(GCC) -o $(GETPGRP) obj/$(GETPGRP).o $(LDFLAGS)
$(GETPGRP).o:
	$(GCC) -o obj/$(GETPGRP).o -c $(GETPGRP).c $(CFLAGS)

$(GETPID): $(GETPID).o
	$(GCC) -o $(GETPID) obj/$(GETPID).o $(LDFLAGS)
$(GETPID).o:
	$(GCC) -o obj/$(GETPID).o -c $(GETPID).c $(CFLAGS)

$(GETPPID): $(GETPPID).o
	$(GCC) -o $(GETPPID) obj/$(GETPPID).o $(LDFLAGS)
$(GETPPID).o:
	$(GCC) -o obj/$(GETPPID).o -c $(GETPPID).c $(CFLAGS)

$(GETPWENT): $(GETPWENT).o
	$(GCC) -o $(GETPWENT) obj/$(GETPWENT).o $(LDFLAGS)
$(GETPWENT).o:
	$(GCC) -o obj/$(GETPWENT).o -c $(GETPWENT).c $(CFLAGS)

$(GETPWNAM): $(GETPWNAM).o
	$(GCC) -o $(GETPWNAM) obj/$(GETPWNAM).o $(LDFLAGS)
$(GETPWNAM).o:
	$(GCC) -o obj/$(GETPWNAM).o -c $(GETPWNAM).c $(CFLAGS)

$(GETPWUID): $(GETPWUID).o
	$(GCC) -o $(GETPWUID) obj/$(GETPWUID).o $(LDFLAGS)
$(GETPWUID).o:
	$(GCC) -o obj/$(GETPWUID).o -c $(GETPWUID).c $(CFLAGS)

$(GETSID): $(GETSID).o
	$(GCC) -o $(GETSID) obj/$(GETSID).o $(LDFLAGS)
$(GETSID).o:
	$(GCC) -o obj/$(GETSID).o -c $(GETSID).c $(CFLAGS)

$(GETUID): $(GETUID).o
	$(GCC) -o $(GETUID) obj/$(GETUID).o $(LDFLAGS)
$(GETUID).o:
	$(GCC) -o obj/$(GETUID).o -c $(GETUID).c $(CFLAGS)

$(GETUSERSHELL): $(GETUSERSHELL).o
	$(GCC) -o $(GETUSERSHELL) obj/$(GETUSERSHELL).o $(LDFLAGS)
$(GETUSERSHELL).o:
	$(GCC) -o obj/$(GETUSERSHELL).o -c $(GETUSERSHELL).c $(CFLAGS)

$(ISATTY): $(ISATTY).o
	$(GCC) -o $(ISATTY) obj/$(ISATTY).o $(LDFLAGS)
$(ISATTY).o:
	$(GCC) -o obj/$(ISATTY).o -c $(ISATTY).c $(CFLAGS)

$(SETEGID): $(SETEGID).o
	$(GCC) -o $(SETEGID) obj/$(SETEGID).o $(LDFLAGS)
$(SETEGID).o:
	$(GCC) -o obj/$(SETEGID).o -c $(SETEGID).c $(CFLAGS)

$(SETEUID): $(SETEUID).o
	$(GCC) -o $(SETEUID) obj/$(SETEUID).o $(LDFLAGS)
$(SETEUID).o:
	$(GCC) -o obj/$(SETEUID).o -c $(SETEUID).c $(CFLAGS)

$(SETGID): $(SETGID).o
	$(GCC) -o $(SETGID) obj/$(SETGID).o $(LDFLAGS)
$(SETGID).o:
	$(GCC) -o obj/$(SETGID).o -c $(SETGID).c $(CFLAGS)

$(SETGRENT): $(SETGRENT).o
	$(GCC) -o $(SETGRENT) obj/$(SETGRENT).o $(LDFLAGS)
$(SETGRENT).o:
	$(GCC) -o obj/$(SETGRENT).o -c $(SETGRENT).c $(CFLAGS)

$(SETLOGIN): $(SETLOGIN).o
	$(GCC) -o $(SETLOGIN) obj/$(SETLOGIN).o $(LDFLAGS)
$(SETLOGIN).o:
	$(GCC) -o obj/$(SETLOGIN).o -c $(SETLOGIN).c $(CFLAGS)

$(SETPGID): $(SETPGID).o
	$(GCC) -o $(SETPGID) obj/$(SETPGID).o $(LDFLAGS)
$(SETPGID).o:
	$(GCC) -o obj/$(SETPGID).o -c $(SETPGID).c $(CFLAGS)

$(SETPGRP): $(SETPGRP).o
	$(GCC) -o $(SETPGRP) obj/$(SETPGRP).o $(LDFLAGS)
$(SETPGRP).o:
	$(GCC) -o obj/$(SETPGRP).o -c $(SETPGRP).c $(CFLAGS)

$(SETPWENT): $(SETPWENT).o
	$(GCC) -o $(SETPWENT) obj/$(SETPWENT).o $(LDFLAGS)
$(SETPWENT).o:
	$(GCC) -o obj/$(SETPWENT).o -c $(SETPWENT).c $(CFLAGS)

$(SETSID): $(SETSID).o
	$(GCC) -o $(SETSID) obj/$(SETSID).o $(LDFLAGS)
$(SETSID).o:
	$(GCC) -o obj/$(SETSID).o -c $(SETSID).c $(CFLAGS)

$(SETUID): $(SETUID).o
	$(GCC) -o $(SETUID) obj/$(SETUID).o $(LDFLAGS)
$(SETUID).o:
	$(GCC) -o obj/$(SETUID).o -c $(SETUID).c $(CFLAGS)

$(SETUSERSHELL): $(SETUSERSHELL).o
	$(GCC) -o $(SETUSERSHELL) obj/$(SETUSERSHELL).o $(LDFLAGS)
$(SETUSERSHELL).o:
	$(GCC) -o obj/$(SETUSERSHELL).o -c $(SETUSERSHELL).c $(CFLAGS)

$(TTYNAME): $(TTYNAME).o
	$(GCC) -o $(TTYNAME) obj/$(TTYNAME).o $(LDFLAGS)
$(TTYNAME).o:
	$(GCC) -o obj/$(TTYNAME).o -c $(TTYNAME).c $(CFLAGS)

$(TTYSLOT): $(TTYSLOT).o
	$(GCC) -o $(TTYSLOT) obj/$(TTYSLOT).o $(LDFLAGS)
$(TTYSLOT).o:
	$(GCC) -o obj/$(TTYSLOT).o -c $(TTYSLOT).c $(CFLAGS)

$(UNAME): $(UNAME).o
	$(GCC) -o $(UNAME) obj/$(UNAME).o $(LDFLAGS)
$(UNAME).o:
	$(GCC) -o obj/$(UNAME).o -c $(UNAME).c $(CFLAGS)

#top Makefile.fbsd¶

SELECT ALL

# Project: Project
# Makefile created

GCC         = gcc
INCS        = -DHAVE_ENDUSERSHELL=1 -DHAVE_SETLOGIN=1 -DHAVE_GETPGRP_2ARGS=1 -DHAVE_SETPGRP_2ARGS=1 -DHAVE_GETLOADAVG=1 -DHAVE_GETPASS=1 -DHAVE_GETUSERSHELL=1 -DHAVE_SETUSERSHELL=1 -DHAVE_GETPGID=1 -DHAVE_SETPGID=1 -DHAVE_TTYSLOT=1
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing -Wno-long-long -D_FILE_OFFSET_BITS=64 -D_LINUX -D_REENTRANT
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing
LIBS        =
LIBDIRS     =
LDFLAGS     = $(LIBDIRS) $(LIBS)
RM          = rm -f
MKDIR       = mkdir -p

ENDGRENT    = endgrent
ENDPWENT    = endpwent
ENDUSERSHELL= endusershell
GETEGID     = getegid
GETEUID     = geteuid
GETGID      = getgid
GETGRENT    = getgrent
GETGRGID    = getgrgid
GETGRNAM    = getgrnam
GETLOADAVG  = getloadavg
GETLOGIN    = getlogin
GETPASS     = getpass
GETPGID     = getpgid
GETPGRP     = getpgrp
GETPID      = getpid
GETPPID     = getppid
GETPWENT    = getpwent
GETPWNAM    = getpwnam
GETPWUID    = getpwuid
GETSID      = getsid
GETUID      = getuid
GETUSERSHELL= getusershell
ISATTY      = isatty
SETEGID     = setegid
SETEUID     = seteuid
SETGID      = setgid
SETGRENT    = setgrent
SETLOGIN    = setlogin
SETPGID     = setpgid
SETPGRP     = setpgrp
SETPWENT    = setpwent
SETSID      = setsid
SETUID      = setuid
SETUSERSHELL= setusershell
TTYNAME     = ttyname
TTYSLOT     = ttyslot
UNAME       = uname



all: objdir make

objdir:
	$(MKDIR) obj/

clean: objdir
	$(RM) obj/*.o *.o *~

#make: $(ENDGRENT)
#make: $(ENDPWENT)
#make: $(ENDUSERSHELL)
#make: $(GETEGID)
#make: $(GETEUID)
#make: $(GETGID)
#make: $(GETGRENT)
#make: $(GETGRGID)
#make: $(GETGRNAM)
#make: $(GETLOADAVG)
#make: $(GETLOGIN)
#make: $(GETPASS)
#make: $(GETPGID)
#make: $(GETPGRP)
#make: $(GETPID)
#make: $(GETPPID)
#make: $(GETPWENT)
#make: $(GETPWNAM)
#make: $(GETPWUID)
#make: $(GETSID)
#make: $(GETUID)
#make: $(GETUSERSHELL)
#make: $(ISATTY)
#make: $(SETEGID)
#make: $(SETEUID)
#make: $(SETGID)
#make: $(SETGRENT)
#make: $(SETLOGIN)
#make: $(SETPGID)
#make: $(SETPGRP)
#make: $(SETPWENT)
#make: $(SETSID)
#make: $(SETUID)
#make: $(SETUSERSHELL)
#make: $(TTYNAME)
#make: $(TTYSLOT)
#make: $(UNAME)
make: $(ENDGRENT) $(ENDPWENT) $(ENDUSERSHELL) $(GETEGID) $(GETEUID) $(GETGID) $(GETGRENT) $(GETGRGID) $(GETGRNAM) $(GETLOADAVG) $(GETLOGIN) $(GETPASS) $(GETPGID) $(GETPGRP) $(GETPID) $(GETPPID) $(GETPWENT) $(GETPWNAM) $(GETPWUID) $(GETSID) $(GETUID) $(GETUSERSHELL) $(ISATTY) $(SETEGID) $(SETEUID) $(SETGID) $(SETGRENT) $(SETLOGIN) $(SETPGID) $(SETPGRP) $(SETPWENT) $(SETSID) $(SETUID) $(SETUSERSHELL) $(TTYNAME) $(TTYSLOT) $(UNAME)



$(ENDGRENT): $(ENDGRENT).o
	$(GCC) -o $(ENDGRENT) obj/$(ENDGRENT).o $(LDFLAGS)
$(ENDGRENT).o:
	$(GCC) -o obj/$(ENDGRENT).o -c $(ENDGRENT).c $(CFLAGS)

$(ENDPWENT): $(ENDPWENT).o
	$(GCC) -o $(ENDPWENT) obj/$(ENDPWENT).o $(LDFLAGS)
$(ENDPWENT).o:
	$(GCC) -o obj/$(ENDPWENT).o -c $(ENDPWENT).c $(CFLAGS)

$(ENDUSERSHELL): $(ENDUSERSHELL).o
	$(GCC) -o $(ENDUSERSHELL) obj/$(ENDUSERSHELL).o $(LDFLAGS)
$(ENDUSERSHELL).o:
	$(GCC) -o obj/$(ENDUSERSHELL).o -c $(ENDUSERSHELL).c $(CFLAGS)

$(GETEGID): $(GETEGID).o
	$(GCC) -o $(GETEGID) obj/$(GETEGID).o $(LDFLAGS)
$(GETEGID).o:
	$(GCC) -o obj/$(GETEGID).o -c $(GETEGID).c $(CFLAGS)

$(GETEUID): $(GETEUID).o
	$(GCC) -o $(GETEUID) obj/$(GETEUID).o $(LDFLAGS)
$(GETEUID).o:
	$(GCC) -o obj/$(GETEUID).o -c $(GETEUID).c $(CFLAGS)

$(GETGID): $(GETGID).o
	$(GCC) -o $(GETGID) obj/$(GETGID).o $(LDFLAGS)
$(GETGID).o:
	$(GCC) -o obj/$(GETGID).o -c $(GETGID).c $(CFLAGS)

$(GETGRENT): $(GETGRENT).o
	$(GCC) -o $(GETGRENT) obj/$(GETGRENT).o $(LDFLAGS)
$(GETGRENT).o:
	$(GCC) -o obj/$(GETGRENT).o -c $(GETGRENT).c $(CFLAGS)

$(GETGRGID): $(GETGRGID).o
	$(GCC) -o $(GETGRGID) obj/$(GETGRGID).o $(LDFLAGS)
$(GETGRGID).o:
	$(GCC) -o obj/$(GETGRGID).o -c $(GETGRGID).c $(CFLAGS)

$(GETGRNAM): $(GETGRNAM).o
	$(GCC) -o $(GETGRNAM) obj/$(GETGRNAM).o $(LDFLAGS)
$(GETGRNAM).o:
	$(GCC) -o obj/$(GETGRNAM).o -c $(GETGRNAM).c $(CFLAGS)

$(GETLOADAVG): $(GETLOADAVG).o
	$(GCC) -o $(GETLOADAVG) obj/$(GETLOADAVG).o $(LDFLAGS)
$(GETLOADAVG).o:
	$(GCC) -o obj/$(GETLOADAVG).o -c $(GETLOADAVG).c $(CFLAGS)

$(GETLOGIN): $(GETLOGIN).o
	$(GCC) -o $(GETLOGIN) obj/$(GETLOGIN).o $(LDFLAGS)
$(GETLOGIN).o:
	$(GCC) -o obj/$(GETLOGIN).o -c $(GETLOGIN).c $(CFLAGS)

$(GETPASS): $(GETPASS).o
	$(GCC) -o $(GETPASS) obj/$(GETPASS).o $(LDFLAGS)
$(GETPASS).o:
	$(GCC) -o obj/$(GETPASS).o -c $(GETPASS).c $(CFLAGS)

$(GETPGID): $(GETPGID).o
	$(GCC) -o $(GETPGID) obj/$(GETPGID).o $(LDFLAGS)
$(GETPGID).o:
	$(GCC) -o obj/$(GETPGID).o -c $(GETPGID).c $(CFLAGS)

$(GETPGRP): $(GETPGRP).o
	$(GCC) -o $(GETPGRP) obj/$(GETPGRP).o $(LDFLAGS)
$(GETPGRP).o:
	$(GCC) -o obj/$(GETPGRP).o -c $(GETPGRP).c $(CFLAGS)

$(GETPID): $(GETPID).o
	$(GCC) -o $(GETPID) obj/$(GETPID).o $(LDFLAGS)
$(GETPID).o:
	$(GCC) -o obj/$(GETPID).o -c $(GETPID).c $(CFLAGS)

$(GETPPID): $(GETPPID).o
	$(GCC) -o $(GETPPID) obj/$(GETPPID).o $(LDFLAGS)
$(GETPPID).o:
	$(GCC) -o obj/$(GETPPID).o -c $(GETPPID).c $(CFLAGS)

$(GETPWENT): $(GETPWENT).o
	$(GCC) -o $(GETPWENT) obj/$(GETPWENT).o $(LDFLAGS)
$(GETPWENT).o:
	$(GCC) -o obj/$(GETPWENT).o -c $(GETPWENT).c $(CFLAGS)

$(GETPWNAM): $(GETPWNAM).o
	$(GCC) -o $(GETPWNAM) obj/$(GETPWNAM).o $(LDFLAGS)
$(GETPWNAM).o:
	$(GCC) -o obj/$(GETPWNAM).o -c $(GETPWNAM).c $(CFLAGS)

$(GETPWUID): $(GETPWUID).o
	$(GCC) -o $(GETPWUID) obj/$(GETPWUID).o $(LDFLAGS)
$(GETPWUID).o:
	$(GCC) -o obj/$(GETPWUID).o -c $(GETPWUID).c $(CFLAGS)

$(GETSID): $(GETSID).o
	$(GCC) -o $(GETSID) obj/$(GETSID).o $(LDFLAGS)
$(GETSID).o:
	$(GCC) -o obj/$(GETSID).o -c $(GETSID).c $(CFLAGS)

$(GETUID): $(GETUID).o
	$(GCC) -o $(GETUID) obj/$(GETUID).o $(LDFLAGS)
$(GETUID).o:
	$(GCC) -o obj/$(GETUID).o -c $(GETUID).c $(CFLAGS)

$(GETUSERSHELL): $(GETUSERSHELL).o
	$(GCC) -o $(GETUSERSHELL) obj/$(GETUSERSHELL).o $(LDFLAGS)
$(GETUSERSHELL).o:
	$(GCC) -o obj/$(GETUSERSHELL).o -c $(GETUSERSHELL).c $(CFLAGS)

$(ISATTY): $(ISATTY).o
	$(GCC) -o $(ISATTY) obj/$(ISATTY).o $(LDFLAGS)
$(ISATTY).o:
	$(GCC) -o obj/$(ISATTY).o -c $(ISATTY).c $(CFLAGS)

$(SETEGID): $(SETEGID).o
	$(GCC) -o $(SETEGID) obj/$(SETEGID).o $(LDFLAGS)
$(SETEGID).o:
	$(GCC) -o obj/$(SETEGID).o -c $(SETEGID).c $(CFLAGS)

$(SETEUID): $(SETEUID).o
	$(GCC) -o $(SETEUID) obj/$(SETEUID).o $(LDFLAGS)
$(SETEUID).o:
	$(GCC) -o obj/$(SETEUID).o -c $(SETEUID).c $(CFLAGS)

$(SETGID): $(SETGID).o
	$(GCC) -o $(SETGID) obj/$(SETGID).o $(LDFLAGS)
$(SETGID).o:
	$(GCC) -o obj/$(SETGID).o -c $(SETGID).c $(CFLAGS)

$(SETGRENT): $(SETGRENT).o
	$(GCC) -o $(SETGRENT) obj/$(SETGRENT).o $(LDFLAGS)
$(SETGRENT).o:
	$(GCC) -o obj/$(SETGRENT).o -c $(SETGRENT).c $(CFLAGS)

$(SETLOGIN): $(SETLOGIN).o
	$(GCC) -o $(SETLOGIN) obj/$(SETLOGIN).o $(LDFLAGS)
$(SETLOGIN).o:
	$(GCC) -o obj/$(SETLOGIN).o -c $(SETLOGIN).c $(CFLAGS)

$(SETPGID): $(SETPGID).o
	$(GCC) -o $(SETPGID) obj/$(SETPGID).o $(LDFLAGS)
$(SETPGID).o:
	$(GCC) -o obj/$(SETPGID).o -c $(SETPGID).c $(CFLAGS)

$(SETPGRP): $(SETPGRP).o
	$(GCC) -o $(SETPGRP) obj/$(SETPGRP).o $(LDFLAGS)
$(SETPGRP).o:
	$(GCC) -o obj/$(SETPGRP).o -c $(SETPGRP).c $(CFLAGS)

$(SETPWENT): $(SETPWENT).o
	$(GCC) -o $(SETPWENT) obj/$(SETPWENT).o $(LDFLAGS)
$(SETPWENT).o:
	$(GCC) -o obj/$(SETPWENT).o -c $(SETPWENT).c $(CFLAGS)

$(SETSID): $(SETSID).o
	$(GCC) -o $(SETSID) obj/$(SETSID).o $(LDFLAGS)
$(SETSID).o:
	$(GCC) -o obj/$(SETSID).o -c $(SETSID).c $(CFLAGS)

$(SETUID): $(SETUID).o
	$(GCC) -o $(SETUID) obj/$(SETUID).o $(LDFLAGS)
$(SETUID).o:
	$(GCC) -o obj/$(SETUID).o -c $(SETUID).c $(CFLAGS)

$(SETUSERSHELL): $(SETUSERSHELL).o
	$(GCC) -o $(SETUSERSHELL) obj/$(SETUSERSHELL).o $(LDFLAGS)
$(SETUSERSHELL).o:
	$(GCC) -o obj/$(SETUSERSHELL).o -c $(SETUSERSHELL).c $(CFLAGS)

$(TTYNAME): $(TTYNAME).o
	$(GCC) -o $(TTYNAME) obj/$(TTYNAME).o $(LDFLAGS)
$(TTYNAME).o:
	$(GCC) -o obj/$(TTYNAME).o -c $(TTYNAME).c $(CFLAGS)

$(TTYSLOT): $(TTYSLOT).o
	$(GCC) -o $(TTYSLOT) obj/$(TTYSLOT).o $(LDFLAGS)
$(TTYSLOT).o:
	$(GCC) -o obj/$(TTYSLOT).o -c $(TTYSLOT).c $(CFLAGS)

$(UNAME): $(UNAME).o
	$(GCC) -o $(UNAME) obj/$(UNAME).o $(LDFLAGS)
$(UNAME).o:
	$(GCC) -o obj/$(UNAME).o -c $(UNAME).c $(CFLAGS)

#top Makefile.sol¶

SELECT ALL

# Project: Project
# Makefile created

GCC         = gcc
INCS        = -DHAVE_ENDUSERSHELL=1 -DHAVE_GETPGRP_0ARGS=1 -DHAVE_SETPGRP_0ARGS=1 -DHAVE_GETLOADAVG=1 -DHAVE_GETPASS=1 -DHAVE_GETUSERSHELL=1 -DHAVE_SETUSERSHELL=1 -DHAVE_GETPGID=1 -DHAVE_SETPGID=1 -DHAVE_TTYSLOT=1
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing -Wno-long-long -D_FILE_OFFSET_BITS=64 -D_LINUX -D_REENTRANT
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing
LIBS        =
LIBDIRS     =
LDFLAGS     = $(LIBDIRS) $(LIBS)
RM          = rm -f
MKDIR       = mkdir -p

ENDGRENT    = endgrent
ENDPWENT    = endpwent
ENDUSERSHELL= endusershell
GETEGID     = getegid
GETEUID     = geteuid
GETGID      = getgid
GETGRENT    = getgrent
GETGRGID    = getgrgid
GETGRNAM    = getgrnam
GETLOADAVG  = getloadavg
GETLOGIN    = getlogin
GETPASS     = getpass
GETPGID     = getpgid
GETPGRP     = getpgrp
GETPID      = getpid
GETPPID     = getppid
GETPWENT    = getpwent
GETPWNAM    = getpwnam
GETPWUID    = getpwuid
GETSID      = getsid
GETUID      = getuid
GETUSERSHELL= getusershell
ISATTY      = isatty
SETEGID     = setegid
SETEUID     = seteuid
SETGID      = setgid
SETGRENT    = setgrent
SETLOGIN    = setlogin
SETPGID     = setpgid
SETPGRP     = setpgrp
SETPWENT    = setpwent
SETSID      = setsid
SETUID      = setuid
SETUSERSHELL= setusershell
TTYNAME     = ttyname
TTYSLOT     = ttyslot
UNAME       = uname



all: objdir make

objdir:
	$(MKDIR) obj/

clean: objdir
	$(RM) obj/*.o *.o *~

#make: $(ENDGRENT)
#make: $(ENDPWENT)
#make: $(ENDUSERSHELL)
#make: $(GETEGID)
#make: $(GETEUID)
#make: $(GETGID)
#make: $(GETGRENT)
#make: $(GETGRGID)
#make: $(GETGRNAM)
#make: $(GETLOADAVG)
#make: $(GETLOGIN)
#make: $(GETPASS)
#make: $(GETPGID)
#make: $(GETPGRP)
#make: $(GETPID)
#make: $(GETPPID)
#make: $(GETPWENT)
#make: $(GETPWNAM)
#make: $(GETPWUID)
#make: $(GETSID)
#make: $(GETUID)
#make: $(GETUSERSHELL)
#make: $(ISATTY)
#make: $(SETEGID)
#make: $(SETEUID)
#make: $(SETGID)
#make: $(SETGRENT)
#make: $(SETLOGIN)
#make: $(SETPGID)
#make: $(SETPGRP)
#make: $(SETPWENT)
#make: $(SETSID)
#make: $(SETUID)
#make: $(SETUSERSHELL)
#make: $(TTYNAME)
#make: $(TTYSLOT)
#make: $(UNAME)
make: $(ENDGRENT) $(ENDPWENT) $(ENDUSERSHELL) $(GETEGID) $(GETEUID) $(GETGID) $(GETGRENT) $(GETGRGID) $(GETGRNAM) $(GETLOADAVG) $(GETLOGIN) $(GETPASS) $(GETPGID) $(GETPGRP) $(GETPID) $(GETPPID) $(GETPWENT) $(GETPWNAM) $(GETPWUID) $(GETSID) $(GETUID) $(GETUSERSHELL) $(ISATTY) $(SETEGID) $(SETEUID) $(SETGID) $(SETGRENT) $(SETLOGIN) $(SETPGID) $(SETPGRP) $(SETPWENT) $(SETSID) $(SETUID) $(SETUSERSHELL) $(TTYNAME) $(TTYSLOT) $(UNAME)



$(ENDGRENT): $(ENDGRENT).o
	$(GCC) -o $(ENDGRENT) obj/$(ENDGRENT).o $(LDFLAGS)
$(ENDGRENT).o:
	$(GCC) -o obj/$(ENDGRENT).o -c $(ENDGRENT).c $(CFLAGS)

$(ENDPWENT): $(ENDPWENT).o
	$(GCC) -o $(ENDPWENT) obj/$(ENDPWENT).o $(LDFLAGS)
$(ENDPWENT).o:
	$(GCC) -o obj/$(ENDPWENT).o -c $(ENDPWENT).c $(CFLAGS)

$(ENDUSERSHELL): $(ENDUSERSHELL).o
	$(GCC) -o $(ENDUSERSHELL) obj/$(ENDUSERSHELL).o $(LDFLAGS)
$(ENDUSERSHELL).o:
	$(GCC) -o obj/$(ENDUSERSHELL).o -c $(ENDUSERSHELL).c $(CFLAGS)

$(GETEGID): $(GETEGID).o
	$(GCC) -o $(GETEGID) obj/$(GETEGID).o $(LDFLAGS)
$(GETEGID).o:
	$(GCC) -o obj/$(GETEGID).o -c $(GETEGID).c $(CFLAGS)

$(GETEUID): $(GETEUID).o
	$(GCC) -o $(GETEUID) obj/$(GETEUID).o $(LDFLAGS)
$(GETEUID).o:
	$(GCC) -o obj/$(GETEUID).o -c $(GETEUID).c $(CFLAGS)

$(GETGID): $(GETGID).o
	$(GCC) -o $(GETGID) obj/$(GETGID).o $(LDFLAGS)
$(GETGID).o:
	$(GCC) -o obj/$(GETGID).o -c $(GETGID).c $(CFLAGS)

$(GETGRENT): $(GETGRENT).o
	$(GCC) -o $(GETGRENT) obj/$(GETGRENT).o $(LDFLAGS)
$(GETGRENT).o:
	$(GCC) -o obj/$(GETGRENT).o -c $(GETGRENT).c $(CFLAGS)

$(GETGRGID): $(GETGRGID).o
	$(GCC) -o $(GETGRGID) obj/$(GETGRGID).o $(LDFLAGS)
$(GETGRGID).o:
	$(GCC) -o obj/$(GETGRGID).o -c $(GETGRGID).c $(CFLAGS)

$(GETGRNAM): $(GETGRNAM).o
	$(GCC) -o $(GETGRNAM) obj/$(GETGRNAM).o $(LDFLAGS)
$(GETGRNAM).o:
	$(GCC) -o obj/$(GETGRNAM).o -c $(GETGRNAM).c $(CFLAGS)

$(GETLOADAVG): $(GETLOADAVG).o
	$(GCC) -o $(GETLOADAVG) obj/$(GETLOADAVG).o $(LDFLAGS)
$(GETLOADAVG).o:
	$(GCC) -o obj/$(GETLOADAVG).o -c $(GETLOADAVG).c $(CFLAGS)

$(GETLOGIN): $(GETLOGIN).o
	$(GCC) -o $(GETLOGIN) obj/$(GETLOGIN).o $(LDFLAGS)
$(GETLOGIN).o:
	$(GCC) -o obj/$(GETLOGIN).o -c $(GETLOGIN).c $(CFLAGS)

$(GETPASS): $(GETPASS).o
	$(GCC) -o $(GETPASS) obj/$(GETPASS).o $(LDFLAGS)
$(GETPASS).o:
	$(GCC) -o obj/$(GETPASS).o -c $(GETPASS).c $(CFLAGS)

$(GETPGID): $(GETPGID).o
	$(GCC) -o $(GETPGID) obj/$(GETPGID).o $(LDFLAGS)
$(GETPGID).o:
	$(GCC) -o obj/$(GETPGID).o -c $(GETPGID).c $(CFLAGS)

$(GETPGRP): $(GETPGRP).o
	$(GCC) -o $(GETPGRP) obj/$(GETPGRP).o $(LDFLAGS)
$(GETPGRP).o:
	$(GCC) -o obj/$(GETPGRP).o -c $(GETPGRP).c $(CFLAGS)

$(GETPID): $(GETPID).o
	$(GCC) -o $(GETPID) obj/$(GETPID).o $(LDFLAGS)
$(GETPID).o:
	$(GCC) -o obj/$(GETPID).o -c $(GETPID).c $(CFLAGS)

$(GETPPID): $(GETPPID).o
	$(GCC) -o $(GETPPID) obj/$(GETPPID).o $(LDFLAGS)
$(GETPPID).o:
	$(GCC) -o obj/$(GETPPID).o -c $(GETPPID).c $(CFLAGS)

$(GETPWENT): $(GETPWENT).o
	$(GCC) -o $(GETPWENT) obj/$(GETPWENT).o $(LDFLAGS)
$(GETPWENT).o:
	$(GCC) -o obj/$(GETPWENT).o -c $(GETPWENT).c $(CFLAGS)

$(GETPWNAM): $(GETPWNAM).o
	$(GCC) -o $(GETPWNAM) obj/$(GETPWNAM).o $(LDFLAGS)
$(GETPWNAM).o:
	$(GCC) -o obj/$(GETPWNAM).o -c $(GETPWNAM).c $(CFLAGS)

$(GETPWUID): $(GETPWUID).o
	$(GCC) -o $(GETPWUID) obj/$(GETPWUID).o $(LDFLAGS)
$(GETPWUID).o:
	$(GCC) -o obj/$(GETPWUID).o -c $(GETPWUID).c $(CFLAGS)

$(GETSID): $(GETSID).o
	$(GCC) -o $(GETSID) obj/$(GETSID).o $(LDFLAGS)
$(GETSID).o:
	$(GCC) -o obj/$(GETSID).o -c $(GETSID).c $(CFLAGS)

$(GETUID): $(GETUID).o
	$(GCC) -o $(GETUID) obj/$(GETUID).o $(LDFLAGS)
$(GETUID).o:
	$(GCC) -o obj/$(GETUID).o -c $(GETUID).c $(CFLAGS)

$(GETUSERSHELL): $(GETUSERSHELL).o
	$(GCC) -o $(GETUSERSHELL) obj/$(GETUSERSHELL).o $(LDFLAGS)
$(GETUSERSHELL).o:
	$(GCC) -o obj/$(GETUSERSHELL).o -c $(GETUSERSHELL).c $(CFLAGS)

$(ISATTY): $(ISATTY).o
	$(GCC) -o $(ISATTY) obj/$(ISATTY).o $(LDFLAGS)
$(ISATTY).o:
	$(GCC) -o obj/$(ISATTY).o -c $(ISATTY).c $(CFLAGS)

$(SETEGID): $(SETEGID).o
	$(GCC) -o $(SETEGID) obj/$(SETEGID).o $(LDFLAGS)
$(SETEGID).o:
	$(GCC) -o obj/$(SETEGID).o -c $(SETEGID).c $(CFLAGS)

$(SETEUID): $(SETEUID).o
	$(GCC) -o $(SETEUID) obj/$(SETEUID).o $(LDFLAGS)
$(SETEUID).o:
	$(GCC) -o obj/$(SETEUID).o -c $(SETEUID).c $(CFLAGS)

$(SETGID): $(SETGID).o
	$(GCC) -o $(SETGID) obj/$(SETGID).o $(LDFLAGS)
$(SETGID).o:
	$(GCC) -o obj/$(SETGID).o -c $(SETGID).c $(CFLAGS)

$(SETGRENT): $(SETGRENT).o
	$(GCC) -o $(SETGRENT) obj/$(SETGRENT).o $(LDFLAGS)
$(SETGRENT).o:
	$(GCC) -o obj/$(SETGRENT).o -c $(SETGRENT).c $(CFLAGS)

$(SETLOGIN): $(SETLOGIN).o
	$(GCC) -o $(SETLOGIN) obj/$(SETLOGIN).o $(LDFLAGS)
$(SETLOGIN).o:
	$(GCC) -o obj/$(SETLOGIN).o -c $(SETLOGIN).c $(CFLAGS)

$(SETPGID): $(SETPGID).o
	$(GCC) -o $(SETPGID) obj/$(SETPGID).o $(LDFLAGS)
$(SETPGID).o:
	$(GCC) -o obj/$(SETPGID).o -c $(SETPGID).c $(CFLAGS)

$(SETPGRP): $(SETPGRP).o
	$(GCC) -o $(SETPGRP) obj/$(SETPGRP).o $(LDFLAGS)
$(SETPGRP).o:
	$(GCC) -o obj/$(SETPGRP).o -c $(SETPGRP).c $(CFLAGS)

$(SETPWENT): $(SETPWENT).o
	$(GCC) -o $(SETPWENT) obj/$(SETPWENT).o $(LDFLAGS)
$(SETPWENT).o:
	$(GCC) -o obj/$(SETPWENT).o -c $(SETPWENT).c $(CFLAGS)

$(SETSID): $(SETSID).o
	$(GCC) -o $(SETSID) obj/$(SETSID).o $(LDFLAGS)
$(SETSID).o:
	$(GCC) -o obj/$(SETSID).o -c $(SETSID).c $(CFLAGS)

$(SETUID): $(SETUID).o
	$(GCC) -o $(SETUID) obj/$(SETUID).o $(LDFLAGS)
$(SETUID).o:
	$(GCC) -o obj/$(SETUID).o -c $(SETUID).c $(CFLAGS)

$(SETUSERSHELL): $(SETUSERSHELL).o
	$(GCC) -o $(SETUSERSHELL) obj/$(SETUSERSHELL).o $(LDFLAGS)
$(SETUSERSHELL).o:
	$(GCC) -o obj/$(SETUSERSHELL).o -c $(SETUSERSHELL).c $(CFLAGS)

$(TTYNAME): $(TTYNAME).o
	$(GCC) -o $(TTYNAME) obj/$(TTYNAME).o $(LDFLAGS)
$(TTYNAME).o:
	$(GCC) -o obj/$(TTYNAME).o -c $(TTYNAME).c $(CFLAGS)

$(TTYSLOT): $(TTYSLOT).o
	$(GCC) -o $(TTYSLOT) obj/$(TTYSLOT).o $(LDFLAGS)
$(TTYSLOT).o:
	$(GCC) -o obj/$(TTYSLOT).o -c $(TTYSLOT).c $(CFLAGS)

$(UNAME): $(UNAME).o
	$(GCC) -o $(UNAME) obj/$(UNAME).o $(LDFLAGS)
$(UNAME).o:
	$(GCC) -o obj/$(UNAME).o -c $(UNAME).c $(CFLAGS)

#top Makefile.beos¶

SELECT ALL

# Project: Project
# Makefile created

GCC         = gcc
INCS        =
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing -Wno-long-long -D_FILE_OFFSET_BITS=64 -D_LINUX -D_REENTRANT
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic
LIBS        =
LIBDIRS     =
LDFLAGS     = $(LIBDIRS) $(LIBS)
RM          = rm -f
MKDIR       = mkdir -p

ENDGRENT    = endgrent
ENDPWENT    = endpwent
ENDUSERSHELL= endusershell
GETEGID     = getegid
GETEUID     = geteuid
GETGID      = getgid
GETGRENT    = getgrent
GETGRGID    = getgrgid
GETGRNAM    = getgrnam
GETLOADAVG  = getloadavg
GETLOGIN    = getlogin
GETPASS     = getpass
GETPGID     = getpgid
GETPGRP     = getpgrp
GETPID      = getpid
GETPPID     = getppid
GETPWENT    = getpwent
GETPWNAM    = getpwnam
GETPWUID    = getpwuid
GETSID      = getsid
GETUID      = getuid
GETUSERSHELL= getusershell
ISATTY      = isatty
SETEGID     = setegid
SETEUID     = seteuid
SETGID      = setgid
SETGRENT    = setgrent
SETLOGIN    = setlogin
SETPGID     = setpgid
SETPGRP     = setpgrp
SETPWENT    = setpwent
SETSID      = setsid
SETUID      = setuid
SETUSERSHELL= setusershell
TTYNAME     = ttyname
TTYSLOT     = ttyslot
UNAME       = uname



all: objdir make

objdir:
	$(MKDIR) obj/

clean: objdir
	$(RM) obj/*.o *.o *~

#make: $(ENDGRENT)
#make: $(ENDPWENT)
#make: $(ENDUSERSHELL)
#make: $(GETEGID)
#make: $(GETEUID)
#make: $(GETGID)
#make: $(GETGRENT)
#make: $(GETGRGID)
#make: $(GETGRNAM)
#make: $(GETLOADAVG)
#make: $(GETLOGIN)
#make: $(GETPASS)
#make: $(GETPGID)
#make: $(GETPGRP)
#make: $(GETPID)
#make: $(GETPPID)
#make: $(GETPWENT)
#make: $(GETPWNAM)
#make: $(GETPWUID)
#make: $(GETSID)
#make: $(GETUID)
#make: $(GETUSERSHELL)
#make: $(ISATTY)
#make: $(SETEGID)
#make: $(SETEUID)
#make: $(SETGID)
#make: $(SETGRENT)
#make: $(SETLOGIN)
#make: $(SETPGID)
#make: $(SETPGRP)
#make: $(SETPWENT)
#make: $(SETSID)
#make: $(SETUID)
#make: $(SETUSERSHELL)
#make: $(TTYNAME)
#make: $(TTYSLOT)
#make: $(UNAME)
make: $(ENDGRENT) $(ENDPWENT) $(ENDUSERSHELL) $(GETEGID) $(GETEUID) $(GETGID) $(GETGRENT) $(GETGRGID) $(GETGRNAM) $(GETLOADAVG) $(GETLOGIN) $(GETPASS) $(GETPGID) $(GETPGRP) $(GETPID) $(GETPPID) $(GETPWENT) $(GETPWNAM) $(GETPWUID) $(GETSID) $(GETUID) $(GETUSERSHELL) $(ISATTY) $(SETEGID) $(SETEUID) $(SETGID) $(SETGRENT) $(SETLOGIN) $(SETPGID) $(SETPGRP) $(SETPWENT) $(SETSID) $(SETUID) $(SETUSERSHELL) $(TTYNAME) $(TTYSLOT) $(UNAME)



$(ENDGRENT): $(ENDGRENT).o
	$(GCC) -o $(ENDGRENT) obj/$(ENDGRENT).o $(LDFLAGS)
$(ENDGRENT).o:
	$(GCC) -o obj/$(ENDGRENT).o -c $(ENDGRENT).c $(CFLAGS)

$(ENDPWENT): $(ENDPWENT).o
	$(GCC) -o $(ENDPWENT) obj/$(ENDPWENT).o $(LDFLAGS)
$(ENDPWENT).o:
	$(GCC) -o obj/$(ENDPWENT).o -c $(ENDPWENT).c $(CFLAGS)

$(ENDUSERSHELL): $(ENDUSERSHELL).o
	$(GCC) -o $(ENDUSERSHELL) obj/$(ENDUSERSHELL).o $(LDFLAGS)
$(ENDUSERSHELL).o:
	$(GCC) -o obj/$(ENDUSERSHELL).o -c $(ENDUSERSHELL).c $(CFLAGS)

$(GETEGID): $(GETEGID).o
	$(GCC) -o $(GETEGID) obj/$(GETEGID).o $(LDFLAGS)
$(GETEGID).o:
	$(GCC) -o obj/$(GETEGID).o -c $(GETEGID).c $(CFLAGS)

$(GETEUID): $(GETEUID).o
	$(GCC) -o $(GETEUID) obj/$(GETEUID).o $(LDFLAGS)
$(GETEUID).o:
	$(GCC) -o obj/$(GETEUID).o -c $(GETEUID).c $(CFLAGS)

$(GETGID): $(GETGID).o
	$(GCC) -o $(GETGID) obj/$(GETGID).o $(LDFLAGS)
$(GETGID).o:
	$(GCC) -o obj/$(GETGID).o -c $(GETGID).c $(CFLAGS)

$(GETGRENT): $(GETGRENT).o
	$(GCC) -o $(GETGRENT) obj/$(GETGRENT).o $(LDFLAGS)
$(GETGRENT).o:
	$(GCC) -o obj/$(GETGRENT).o -c $(GETGRENT).c $(CFLAGS)

$(GETGRGID): $(GETGRGID).o
	$(GCC) -o $(GETGRGID) obj/$(GETGRGID).o $(LDFLAGS)
$(GETGRGID).o:
	$(GCC) -o obj/$(GETGRGID).o -c $(GETGRGID).c $(CFLAGS)

$(GETGRNAM): $(GETGRNAM).o
	$(GCC) -o $(GETGRNAM) obj/$(GETGRNAM).o $(LDFLAGS)
$(GETGRNAM).o:
	$(GCC) -o obj/$(GETGRNAM).o -c $(GETGRNAM).c $(CFLAGS)

$(GETLOADAVG): $(GETLOADAVG).o
	$(GCC) -o $(GETLOADAVG) obj/$(GETLOADAVG).o $(LDFLAGS)
$(GETLOADAVG).o:
	$(GCC) -o obj/$(GETLOADAVG).o -c $(GETLOADAVG).c $(CFLAGS)

$(GETLOGIN): $(GETLOGIN).o
	$(GCC) -o $(GETLOGIN) obj/$(GETLOGIN).o $(LDFLAGS)
$(GETLOGIN).o:
	$(GCC) -o obj/$(GETLOGIN).o -c $(GETLOGIN).c $(CFLAGS)

$(GETPASS): $(GETPASS).o
	$(GCC) -o $(GETPASS) obj/$(GETPASS).o $(LDFLAGS)
$(GETPASS).o:
	$(GCC) -o obj/$(GETPASS).o -c $(GETPASS).c $(CFLAGS)

$(GETPGID): $(GETPGID).o
	$(GCC) -o $(GETPGID) obj/$(GETPGID).o $(LDFLAGS)
$(GETPGID).o:
	$(GCC) -o obj/$(GETPGID).o -c $(GETPGID).c $(CFLAGS)

$(GETPGRP): $(GETPGRP).o
	$(GCC) -o $(GETPGRP) obj/$(GETPGRP).o $(LDFLAGS)
$(GETPGRP).o:
	$(GCC) -o obj/$(GETPGRP).o -c $(GETPGRP).c $(CFLAGS)

$(GETPID): $(GETPID).o
	$(GCC) -o $(GETPID) obj/$(GETPID).o $(LDFLAGS)
$(GETPID).o:
	$(GCC) -o obj/$(GETPID).o -c $(GETPID).c $(CFLAGS)

$(GETPPID): $(GETPPID).o
	$(GCC) -o $(GETPPID) obj/$(GETPPID).o $(LDFLAGS)
$(GETPPID).o:
	$(GCC) -o obj/$(GETPPID).o -c $(GETPPID).c $(CFLAGS)

$(GETPWENT): $(GETPWENT).o
	$(GCC) -o $(GETPWENT) obj/$(GETPWENT).o $(LDFLAGS)
$(GETPWENT).o:
	$(GCC) -o obj/$(GETPWENT).o -c $(GETPWENT).c $(CFLAGS)

$(GETPWNAM): $(GETPWNAM).o
	$(GCC) -o $(GETPWNAM) obj/$(GETPWNAM).o $(LDFLAGS)
$(GETPWNAM).o:
	$(GCC) -o obj/$(GETPWNAM).o -c $(GETPWNAM).c $(CFLAGS)

$(GETPWUID): $(GETPWUID).o
	$(GCC) -o $(GETPWUID) obj/$(GETPWUID).o $(LDFLAGS)
$(GETPWUID).o:
	$(GCC) -o obj/$(GETPWUID).o -c $(GETPWUID).c $(CFLAGS)

$(GETSID): $(GETSID).o
	$(GCC) -o $(GETSID) obj/$(GETSID).o $(LDFLAGS)
$(GETSID).o:
	$(GCC) -o obj/$(GETSID).o -c $(GETSID).c $(CFLAGS)

$(GETUID): $(GETUID).o
	$(GCC) -o $(GETUID) obj/$(GETUID).o $(LDFLAGS)
$(GETUID).o:
	$(GCC) -o obj/$(GETUID).o -c $(GETUID).c $(CFLAGS)

$(GETUSERSHELL): $(GETUSERSHELL).o
	$(GCC) -o $(GETUSERSHELL) obj/$(GETUSERSHELL).o $(LDFLAGS)
$(GETUSERSHELL).o:
	$(GCC) -o obj/$(GETUSERSHELL).o -c $(GETUSERSHELL).c $(CFLAGS)

$(ISATTY): $(ISATTY).o
	$(GCC) -o $(ISATTY) obj/$(ISATTY).o $(LDFLAGS)
$(ISATTY).o:
	$(GCC) -o obj/$(ISATTY).o -c $(ISATTY).c $(CFLAGS)

$(SETEGID): $(SETEGID).o
	$(GCC) -o $(SETEGID) obj/$(SETEGID).o $(LDFLAGS)
$(SETEGID).o:
	$(GCC) -o obj/$(SETEGID).o -c $(SETEGID).c $(CFLAGS)

$(SETEUID): $(SETEUID).o
	$(GCC) -o $(SETEUID) obj/$(SETEUID).o $(LDFLAGS)
$(SETEUID).o:
	$(GCC) -o obj/$(SETEUID).o -c $(SETEUID).c $(CFLAGS)

$(SETGID): $(SETGID).o
	$(GCC) -o $(SETGID) obj/$(SETGID).o $(LDFLAGS)
$(SETGID).o:
	$(GCC) -o obj/$(SETGID).o -c $(SETGID).c $(CFLAGS)

$(SETGRENT): $(SETGRENT).o
	$(GCC) -o $(SETGRENT) obj/$(SETGRENT).o $(LDFLAGS)
$(SETGRENT).o:
	$(GCC) -o obj/$(SETGRENT).o -c $(SETGRENT).c $(CFLAGS)

$(SETLOGIN): $(SETLOGIN).o
	$(GCC) -o $(SETLOGIN) obj/$(SETLOGIN).o $(LDFLAGS)
$(SETLOGIN).o:
	$(GCC) -o obj/$(SETLOGIN).o -c $(SETLOGIN).c $(CFLAGS)

$(SETPGID): $(SETPGID).o
	$(GCC) -o $(SETPGID) obj/$(SETPGID).o $(LDFLAGS)
$(SETPGID).o:
	$(GCC) -o obj/$(SETPGID).o -c $(SETPGID).c $(CFLAGS)

$(SETPGRP): $(SETPGRP).o
	$(GCC) -o $(SETPGRP) obj/$(SETPGRP).o $(LDFLAGS)
$(SETPGRP).o:
	$(GCC) -o obj/$(SETPGRP).o -c $(SETPGRP).c $(CFLAGS)

$(SETPWENT): $(SETPWENT).o
	$(GCC) -o $(SETPWENT) obj/$(SETPWENT).o $(LDFLAGS)
$(SETPWENT).o:
	$(GCC) -o obj/$(SETPWENT).o -c $(SETPWENT).c $(CFLAGS)

$(SETSID): $(SETSID).o
	$(GCC) -o $(SETSID) obj/$(SETSID).o $(LDFLAGS)
$(SETSID).o:
	$(GCC) -o obj/$(SETSID).o -c $(SETSID).c $(CFLAGS)

$(SETUID): $(SETUID).o
	$(GCC) -o $(SETUID) obj/$(SETUID).o $(LDFLAGS)
$(SETUID).o:
	$(GCC) -o obj/$(SETUID).o -c $(SETUID).c $(CFLAGS)

$(SETUSERSHELL): $(SETUSERSHELL).o
	$(GCC) -o $(SETUSERSHELL) obj/$(SETUSERSHELL).o $(LDFLAGS)
$(SETUSERSHELL).o:
	$(GCC) -o obj/$(SETUSERSHELL).o -c $(SETUSERSHELL).c $(CFLAGS)

$(TTYNAME): $(TTYNAME).o
	$(GCC) -o $(TTYNAME) obj/$(TTYNAME).o $(LDFLAGS)
$(TTYNAME).o:
	$(GCC) -o obj/$(TTYNAME).o -c $(TTYNAME).c $(CFLAGS)

$(TTYSLOT): $(TTYSLOT).o
	$(GCC) -o $(TTYSLOT) obj/$(TTYSLOT).o $(LDFLAGS)
$(TTYSLOT).o:
	$(GCC) -o obj/$(TTYSLOT).o -c $(TTYSLOT).c $(CFLAGS)

$(UNAME): $(UNAME).o
	$(GCC) -o $(UNAME) obj/$(UNAME).o $(LDFLAGS)
$(UNAME).o:
	$(GCC) -o obj/$(UNAME).o -c $(UNAME).c $(CFLAGS)

#top Makefile.win¶

SELECT ALL

# Project: Project
# Makefile created

GCC         = gcc
INCS        =
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing -Wno-long-long -D_FILE_OFFSET_BITS=64 -D_LINUX -D_REENTRANT
CFLAGS      = $(INCS) -W -O2 -Wall -pedantic -Wstrict-aliasing
LIBS        = -lm
LIBDIRS     =
LDFLAGS     = $(LIBDIRS) $(LIBS)
RM          = del /q /s
MKDIR       = mkdir

ENDGRENT    = endgrent
ENDPWENT    = endpwent
ENDUSERSHELL= endusershell
GETEGID     = getegid
GETEUID     = geteuid
GETGID      = getgid
GETGRENT    = getgrent
GETGRGID    = getgrgid
GETGRNAM    = getgrnam
GETLOADAVG  = getloadavg
GETLOGIN    = getlogin
GETPASS     = getpass
GETPGID     = getpgid
GETPGRP     = getpgrp
GETPID      = getpid
GETPPID     = getppid
GETPWENT    = getpwent
GETPWNAM    = getpwnam
GETPWUID    = getpwuid
GETSID      = getsid
GETUID      = getuid
GETUSERSHELL= getusershell
ISATTY      = isatty
SETEGID     = setegid
SETEUID     = seteuid
SETGID      = setgid
SETGRENT    = setgrent
SETLOGIN    = setlogin
SETPGID     = setpgid
SETPGRP     = setpgrp
SETPWENT    = setpwent
SETSID      = setsid
SETUID      = setuid
SETUSERSHELL= setusershell
TTYNAME     = ttyname
TTYSLOT     = ttyslot
UNAME       = uname



all: make

objdir:
	$(MKDIR) obj\

clean:
	$(RM) obj\*.o *.o *~

#make: $(ENDGRENT)
#make: $(ENDPWENT)
#make: $(ENDUSERSHELL)
#make: $(GETEGID)
#make: $(GETEUID)
#make: $(GETGID)
#make: $(GETGRENT)
#make: $(GETGRGID)
#make: $(GETGRNAM)
#make: $(GETLOADAVG)
#make: $(GETLOGIN)
#make: $(GETPASS)
#make: $(GETPGID)
#make: $(GETPGRP)
#make: $(GETPID)
#make: $(GETPPID)
#make: $(GETPWENT)
#make: $(GETPWNAM)
#make: $(GETPWUID)
#make: $(GETSID)
#make: $(GETUID)
#make: $(GETUSERSHELL)
#make: $(ISATTY)
#make: $(SETEGID)
#make: $(SETEUID)
#make: $(SETGID)
#make: $(SETGRENT)
#make: $(SETLOGIN)
#make: $(SETPGID)
#make: $(SETPGRP)
#make: $(SETPWENT)
#make: $(SETSID)
#make: $(SETUID)
#make: $(SETUSERSHELL)
#make: $(TTYNAME)
#make: $(TTYSLOT)
#make: $(UNAME)
make: $(ENDGRENT) $(ENDPWENT) $(ENDUSERSHELL) $(GETEGID) $(GETEUID) $(GETGID) $(GETGRENT) $(GETGRGID) $(GETGRNAM) $(GETLOADAVG) $(GETLOGIN) $(GETPASS) $(GETPGID) $(GETPGRP) $(GETPID) $(GETPPID) $(GETPWENT) $(GETPWNAM) $(GETPWUID) $(GETSID) $(GETUID) $(GETUSERSHELL) $(ISATTY) $(SETEGID) $(SETEUID) $(SETGID) $(SETGRENT) $(SETLOGIN) $(SETPGID) $(SETPGRP) $(SETPWENT) $(SETSID) $(SETUID) $(SETUSERSHELL) $(TTYNAME) $(TTYSLOT) $(UNAME)



$(ENDGRENT): $(ENDGRENT).o
	$(GCC) -o $(ENDGRENT) obj/$(ENDGRENT).o $(LDFLAGS)
$(ENDGRENT).o:
	$(GCC) -o obj/$(ENDGRENT).o -c $(ENDGRENT).c $(CFLAGS)

$(ENDPWENT): $(ENDPWENT).o
	$(GCC) -o $(ENDPWENT) obj/$(ENDPWENT).o $(LDFLAGS)
$(ENDPWENT).o:
	$(GCC) -o obj/$(ENDPWENT).o -c $(ENDPWENT).c $(CFLAGS)

$(ENDUSERSHELL): $(ENDUSERSHELL).o
	$(GCC) -o $(ENDUSERSHELL) obj/$(ENDUSERSHELL).o $(LDFLAGS)
$(ENDUSERSHELL).o:
	$(GCC) -o obj/$(ENDUSERSHELL).o -c $(ENDUSERSHELL).c $(CFLAGS)

$(GETEGID): $(GETEGID).o
	$(GCC) -o $(GETEGID) obj/$(GETEGID).o $(LDFLAGS)
$(GETEGID).o:
	$(GCC) -o obj/$(GETEGID).o -c $(GETEGID).c $(CFLAGS)

$(GETEUID): $(GETEUID).o
	$(GCC) -o $(GETEUID) obj/$(GETEUID).o $(LDFLAGS)
$(GETEUID).o:
	$(GCC) -o obj/$(GETEUID).o -c $(GETEUID).c $(CFLAGS)

$(GETGID): $(GETGID).o
	$(GCC) -o $(GETGID) obj/$(GETGID).o $(LDFLAGS)
$(GETGID).o:
	$(GCC) -o obj/$(GETGID).o -c $(GETGID).c $(CFLAGS)

$(GETGRENT): $(GETGRENT).o
	$(GCC) -o $(GETGRENT) obj/$(GETGRENT).o $(LDFLAGS)
$(GETGRENT).o:
	$(GCC) -o obj/$(GETGRENT).o -c $(GETGRENT).c $(CFLAGS)

$(GETGRGID): $(GETGRGID).o
	$(GCC) -o $(GETGRGID) obj/$(GETGRGID).o $(LDFLAGS)
$(GETGRGID).o:
	$(GCC) -o obj/$(GETGRGID).o -c $(GETGRGID).c $(CFLAGS)

$(GETGRNAM): $(GETGRNAM).o
	$(GCC) -o $(GETGRNAM) obj/$(GETGRNAM).o $(LDFLAGS)
$(GETGRNAM).o:
	$(GCC) -o obj/$(GETGRNAM).o -c $(GETGRNAM).c $(CFLAGS)

$(GETLOADAVG): $(GETLOADAVG).o
	$(GCC) -o $(GETLOADAVG) obj/$(GETLOADAVG).o $(LDFLAGS)
$(GETLOADAVG).o:
	$(GCC) -o obj/$(GETLOADAVG).o -c $(GETLOADAVG).c $(CFLAGS)

$(GETLOGIN): $(GETLOGIN).o
	$(GCC) -o $(GETLOGIN) obj/$(GETLOGIN).o $(LDFLAGS)
$(GETLOGIN).o:
	$(GCC) -o obj/$(GETLOGIN).o -c $(GETLOGIN).c $(CFLAGS)

$(GETPASS): $(GETPASS).o
	$(GCC) -o $(GETPASS) obj/$(GETPASS).o $(LDFLAGS)
$(GETPASS).o:
	$(GCC) -o obj/$(GETPASS).o -c $(GETPASS).c $(CFLAGS)

$(GETPGID): $(GETPGID).o
	$(GCC) -o $(GETPGID) obj/$(GETPGID).o $(LDFLAGS)
$(GETPGID).o:
	$(GCC) -o obj/$(GETPGID).o -c $(GETPGID).c $(CFLAGS)

$(GETPGRP): $(GETPGRP).o
	$(GCC) -o $(GETPGRP) obj/$(GETPGRP).o $(LDFLAGS)
$(GETPGRP).o:
	$(GCC) -o obj/$(GETPGRP).o -c $(GETPGRP).c $(CFLAGS)

$(GETPID): $(GETPID).o
	$(GCC) -o $(GETPID) obj/$(GETPID).o $(LDFLAGS)
$(GETPID).o:
	$(GCC) -o obj/$(GETPID).o -c $(GETPID).c $(CFLAGS)

$(GETPPID): $(GETPPID).o
	$(GCC) -o $(GETPPID) obj/$(GETPPID).o $(LDFLAGS)
$(GETPPID).o:
	$(GCC) -o obj/$(GETPPID).o -c $(GETPPID).c $(CFLAGS)

$(GETPWENT): $(GETPWENT).o
	$(GCC) -o $(GETPWENT) obj/$(GETPWENT).o $(LDFLAGS)
$(GETPWENT).o:
	$(GCC) -o obj/$(GETPWENT).o -c $(GETPWENT).c $(CFLAGS)

$(GETPWNAM): $(GETPWNAM).o
	$(GCC) -o $(GETPWNAM) obj/$(GETPWNAM).o $(LDFLAGS)
$(GETPWNAM).o:
	$(GCC) -o obj/$(GETPWNAM).o -c $(GETPWNAM).c $(CFLAGS)

$(GETPWUID): $(GETPWUID).o
	$(GCC) -o $(GETPWUID) obj/$(GETPWUID).o $(LDFLAGS)
$(GETPWUID).o:
	$(GCC) -o obj/$(GETPWUID).o -c $(GETPWUID).c $(CFLAGS)

$(GETSID): $(GETSID).o
	$(GCC) -o $(GETSID) obj/$(GETSID).o $(LDFLAGS)
$(GETSID).o:
	$(GCC) -o obj/$(GETSID).o -c $(GETSID).c $(CFLAGS)

$(GETUID): $(GETUID).o
	$(GCC) -o $(GETUID) obj/$(GETUID).o $(LDFLAGS)
$(GETUID).o:
	$(GCC) -o obj/$(GETUID).o -c $(GETUID).c $(CFLAGS)

$(GETUSERSHELL): $(GETUSERSHELL).o
	$(GCC) -o $(GETUSERSHELL) obj/$(GETUSERSHELL).o $(LDFLAGS)
$(GETUSERSHELL).o:
	$(GCC) -o obj/$(GETUSERSHELL).o -c $(GETUSERSHELL).c $(CFLAGS)

$(ISATTY): $(ISATTY).o
	$(GCC) -o $(ISATTY) obj/$(ISATTY).o $(LDFLAGS)
$(ISATTY).o:
	$(GCC) -o obj/$(ISATTY).o -c $(ISATTY).c $(CFLAGS)

$(SETEGID): $(SETEGID).o
	$(GCC) -o $(SETEGID) obj/$(SETEGID).o $(LDFLAGS)
$(SETEGID).o:
	$(GCC) -o obj/$(SETEGID).o -c $(SETEGID).c $(CFLAGS)

$(SETEUID): $(SETEUID).o
	$(GCC) -o $(SETEUID) obj/$(SETEUID).o $(LDFLAGS)
$(SETEUID).o:
	$(GCC) -o obj/$(SETEUID).o -c $(SETEUID).c $(CFLAGS)

$(SETGID): $(SETGID).o
	$(GCC) -o $(SETGID) obj/$(SETGID).o $(LDFLAGS)
$(SETGID).o:
	$(GCC) -o obj/$(SETGID).o -c $(SETGID).c $(CFLAGS)

$(SETGRENT): $(SETGRENT).o
	$(GCC) -o $(SETGRENT) obj/$(SETGRENT).o $(LDFLAGS)
$(SETGRENT).o:
	$(GCC) -o obj/$(SETGRENT).o -c $(SETGRENT).c $(CFLAGS)

$(SETLOGIN): $(SETLOGIN).o
	$(GCC) -o $(SETLOGIN) obj/$(SETLOGIN).o $(LDFLAGS)
$(SETLOGIN).o:
	$(GCC) -o obj/$(SETLOGIN).o -c $(SETLOGIN).c $(CFLAGS)

$(SETPGID): $(SETPGID).o
	$(GCC) -o $(SETPGID) obj/$(SETPGID).o $(LDFLAGS)
$(SETPGID).o:
	$(GCC) -o obj/$(SETPGID).o -c $(SETPGID).c $(CFLAGS)

$(SETPGRP): $(SETPGRP).o
	$(GCC) -o $(SETPGRP) obj/$(SETPGRP).o $(LDFLAGS)
$(SETPGRP).o:
	$(GCC) -o obj/$(SETPGRP).o -c $(SETPGRP).c $(CFLAGS)

$(SETPWENT): $(SETPWENT).o
	$(GCC) -o $(SETPWENT) obj/$(SETPWENT).o $(LDFLAGS)
$(SETPWENT).o:
	$(GCC) -o obj/$(SETPWENT).o -c $(SETPWENT).c $(CFLAGS)

$(SETSID): $(SETSID).o
	$(GCC) -o $(SETSID) obj/$(SETSID).o $(LDFLAGS)
$(SETSID).o:
	$(GCC) -o obj/$(SETSID).o -c $(SETSID).c $(CFLAGS)

$(SETUID): $(SETUID).o
	$(GCC) -o $(SETUID) obj/$(SETUID).o $(LDFLAGS)
$(SETUID).o:
	$(GCC) -o obj/$(SETUID).o -c $(SETUID).c $(CFLAGS)

$(SETUSERSHELL): $(SETUSERSHELL).o
	$(GCC) -o $(SETUSERSHELL) obj/$(SETUSERSHELL).o $(LDFLAGS)
$(SETUSERSHELL).o:
	$(GCC) -o obj/$(SETUSERSHELL).o -c $(SETUSERSHELL).c $(CFLAGS)

$(TTYNAME): $(TTYNAME).o
	$(GCC) -o $(TTYNAME) obj/$(TTYNAME).o $(LDFLAGS)
$(TTYNAME).o:
	$(GCC) -o obj/$(TTYNAME).o -c $(TTYNAME).c $(CFLAGS)

$(TTYSLOT): $(TTYSLOT).o
	$(GCC) -o $(TTYSLOT) obj/$(TTYSLOT).o $(LDFLAGS)
$(TTYSLOT).o:
	$(GCC) -o obj/$(TTYSLOT).o -c $(TTYSLOT).c $(CFLAGS)

$(UNAME): $(UNAME).o
	$(GCC) -o $(UNAME) obj/$(UNAME).o $(LDFLAGS)
$(UNAME).o:
	$(GCC) -o obj/$(UNAME).o -c $(UNAME).c $(CFLAGS)

#top Predefined Constants¶

#top _UTSNAME_LENGTH¶

Deklaracja stałej _UTSNAME_LENGTH znajduje się w pliku nagłówkowym bits/utsname.h.
Deklaracja stałej _UTSNAME_LENGTH jest następująca:

/* Length of the entries in `struct utsname' is 65.  */
#define _UTSNAME_LENGTH 65

#top _UTSNAME_DOMAIN_LENGTH¶

Deklaracja stałej _UTSNAME_DOMAIN_LENGTH znajduje się w pliku nagłówkowym bits/utsname.h.
Deklaracja stałej _UTSNAME_DOMAIN_LENGTH jest następująca:

/* Linux provides as additional information in the `struct utsname'
   the name of the current domain.  Define _UTSNAME_DOMAIN_LENGTH
   to a value != 0 to activate this entry.  */
#define _UTSNAME_DOMAIN_LENGTH _UTSNAME_LENGTH

#top _UTSNAME_MACHINE_LENGTH¶

Deklaracja stałej _UTSNAME_MACHINE_LENGTH znajduje się w pliku nagłówkowym sys/utsname.h.
Deklaracja stałej _UTSNAME_MACHINE_LENGTH jest następująca:

#ifndef _UTSNAME_MACHINE_LENGTH
# define _UTSNAME_MACHINE_LENGTH _UTSNAME_LENGTH
#endif

#top _UTSNAME_NODENAME_LENGTH¶

Deklaracja stałej _UTSNAME_NODENAME_LENGTH znajduje się w pliku nagłówkowym sys/utsname.h.
Deklaracja stałej _UTSNAME_NODENAME_LENGTH jest następująca:

#ifndef _UTSNAME_NODENAME_LENGTH
# define _UTSNAME_NODENAME_LENGTH _UTSNAME_LENGTH
#endif

#top _UTSNAME_RELEASE_LENGTH¶

Deklaracja stałej _UTSNAME_RELEASE_LENGTH znajduje się w pliku nagłówkowym sys/utsname.h.
Deklaracja stałej _UTSNAME_RELEASE_LENGTH jest następująca:

#ifndef _UTSNAME_RELEASE_LENGTH
# define _UTSNAME_RELEASE_LENGTH _UTSNAME_LENGTH
#endif

#top _UTSNAME_SYSNAME_LENGTH¶

Deklaracja stałej _UTSNAME_SYSNAME_LENGTH znajduje się w pliku nagłówkowym sys/utsname.h.
Deklaracja stałej _UTSNAME_SYSNAME_LENGTH jest następująca:

#ifndef _UTSNAME_SYSNAME_LENGTH
# define _UTSNAME_SYSNAME_LENGTH _UTSNAME_LENGTH
#endif

#top _UTSNAME_VERSION_LENGTH¶

Deklaracja stałej _UTSNAME_VERSION_LENGTH znajduje się w pliku nagłówkowym sys/utsname.h.
Deklaracja stałej _UTSNAME_VERSION_LENGTH jest następująca:

#ifndef _UTSNAME_VERSION_LENGTH
# define _UTSNAME_VERSION_LENGTH _UTSNAME_LENGTH
#endif

#top EINVAL¶

Deklaracja stałej EINVAL znajduje się w pliku nagłówkowym asm-generic/errno-base.h.
Deklaracja stałej EINVAL jest następująca:

#define EINVAL      22  /* Invalid argument */

#top Datatypes / MACROS¶

#top __gid_t¶

Definicja typu __gid_t znajduje się w pliku nagłówkowym bits/types.h.
Definicja typu __gid_t jest następująca:

__STD_TYPE __GID_T_TYPE __gid_t;    /* Type of group identifications.  */

#top __pid_t¶

Definicja typu __pid_t znajduje się w pliku nagłówkowym bits/types.h.
Definicja typu __pid_t jest następująca:

__STD_TYPE __PID_T_TYPE __pid_t;    /* Type of process identifications.  */

#top __uid_t¶

Definicja typu __uid_t znajduje się w pliku nagłówkowym bits/types.h.
Definicja typu __uid_t jest następująca:

__STD_TYPE __UID_T_TYPE __uid_t;    /* Type of user identifications.  */

#top gid_t¶

Definicja typu gid_t znajduje się w pliku nagłówkowym grp.h.
Definicja typu gid_t jest następująca:

/* For the Single Unix specification we must define this type here.  */
#if (defined __USE_XOPEN || defined __USE_XOPEN2K) && !defined __gid_t_defined
typedef __gid_t gid_t;
# define __gid_t_defined
#endif

#top pid_t¶

Definicja typu pid_t znajduje się w pliku nagłówkowym unistd.h.
Definicja typu pid_t jest następująca:

# ifndef __pid_t_defined
typedef __pid_t pid_t;
#  define __pid_t_defined
# endif

#top struct group¶

Definicja struktury struct group znajduje się w pliku nagłówkowym grp.h.
Definicja struktury struct group jest następująca:

/* The group structure.  */
struct group
  {
    char *gr_name;      /* Group name.  */
    char *gr_passwd;        /* Password.    */
    __gid_t gr_gid;     :* Group ID.    */
    char **gr_mem;      /* Member list. */
  };

#top struct passwd¶

Definicja struktury struct passwd znajduje się w pliku nagłówkowym pwd.h.
Definicja struktury struct passwd jest następująca:

/* The passwd structure.  */
struct passwd
{
  char *pw_name;        /* Username.  */
  char *pw_passwd;      /* Password.  */
  __uid_t pw_uid;       :* User ID.  */
  __gid_t pw_gid;       :* Group ID.  */
  char *pw_gecos;       /* Real name.  */
  char *pw_dir;         /* Home directory.  */
  char *pw_shell;       /* Shell program.  */
};

#top struct utsname¶

Definicja struktury struct utsname znajduje się w pliku nagłówkowym sys/utsname.h.
Definicja struktury struct utsname jest następująca:

/* Structure describing the system and machine.  */
struct utsname
  {
    /* Name of the implementation of the operating system.  */
    char sysname[_UTSNAME_SYSNAME_LENGTH];

    /* Name of this node on the network.  */
    char nodename[_UTSNAME_NODENAME_LENGTH];

    /* Current release level of this implementation.  */
    char release[_UTSNAME_RELEASE_LENGTH];
    /* Current version level of this release.  */
    char version[_UTSNAME_VERSION_LENGTH];

    /* Name of the hardware type the system is running on.  */
    char machine[_UTSNAME_MACHINE_LENGTH];

#if _UTSNAME_DOMAIN_LENGTH - 0
    /* Name of the domain of this node on the network.  */
# ifdef __USE_GNU
    char domainname[_UTSNAME_DOMAIN_LENGTH];
# else
    char __domainname[_UTSNAME_DOMAIN_LENGTH];
# endif
#endif
  };

#top uid_t¶

Definicja typu uid_t znajduje się w pliku nagłówkowym pwd.h.
Definicja typu uid_t jest następująca:

# ifndef __uid_t_defined
typedef __uid_t uid_t;
#  define __uid_t_defined
# endif
#endif

#top POSIX Functions¶

#top endgrent¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji endgrent() znajduje się w pliku nagłówkowym grp.h.
Deklaracja funkcji endgrent() jest następująca:

/* Close the group-file stream.

   This function is a possible cancellation point and therefore not
   marked with __THROW.  */
extern void endgrent (void);

Powiązane:
endgrent(), getgrent(), getgrgid(), getgrnam(), setgrent(),

Opis:

Funkcja endgrent() jest używana do zamykania "bazy danych" zawierającej informacje dotyczące grup użytkowników w systemie oraz grup do których użytkownicy należą. Informacje dotyczące grup użytkowników w systemie oraz grup do których użytkownicy należą może być przechowywana w pliku tekstowym /etc/group, w bazie Network Information Service (NIS) lub bazie Lightweight Directory Access Protocol (LDAP).

Argumenty:
Funkcja nie przyjmuje żadnych argumentów.

Zwracana wartość:
Funkcja nie zwraca żadnej wartości.

#top endpwent¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji endpwent() znajduje się w pliku nagłówkowym pwd.h.
Deklaracja funkcji endpwent() jest następująca:

/* Close the password-file stream.

   This function is a possible cancellation point and therefore not
   marked with __THROW.  */
extern void endpwent (void);

Powiązane:
endpwent(), getpwent(), getpwnam(), getpwuid(), setpwent(),

Opis:

Funkcja endpwent() jest używana do zamykania "bazy danych" zawierającej informacje dotyczące użytkowników w systemie. Informacje dotyczące użytkowników w systemie może być przechowywana jest w pliku tekstowym /etc/passwd, w bazie Network Information Service (NIS) lub bazie Lightweight Directory Access Protocol (LDAP).

Argumenty:
Funkcja nie przyjmuje żadnych argumentów.

Zwracana wartość:
Funkcja nie zwraca żadnej wartości.

#top endusershell¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji endusershell() znajduje się w pliku nagłówkowym unistd.h.
Deklaracja funkcji endusershell() jest następująca:

/* Successive calls return the shells listed in `/etc/shells'.  */
extern void endusershell (void) __THROW; /* Discard cached info.  */

Powiązane:
endusershell(), getusershell(), setusershell(),

Opis:

Funkcja endusershell() jest używana do zamykania "bazy danych" zawierającej informacje dotyczące powłok systemowych użytkowników posiadających konta w systemie. Informacje dotyczące informacje dotyczące powłok systemowych użytkowników posiadających konta w systemie przechowywane są w pliku tekstowym /etc/shells.

Argumenty:
Funkcja nie przyjmuje żadnych argumentów.

Zwracana wartość:
Funkcja nie zwraca żadnej wartości.

Example:
zawartość pliku endusershell.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <unistd.h>        /* for R_OK, W_OK, X_OK, F_OK, environ, access(), lseek(), close(), read(), write(), pipe(), alarm(), sleep(), ualarm(), usleep(), pause(), chown(), chdir(), getcwd(), */
                           /* for exec[...](), nice(), getpid(), getppid(), setpgid(), setsid(), getsid(), getuid(), geteuid(). getgid(), getegid(), setuid(), seteuid(), setgid(), setegid(), fork(), */
                           /* for link(), symlink(), readlink(), unlink(), rmdir(), getlogin(), setlogin(), gethostname(), sethostname(), daemon(), chroot(), getpass(), [f]sync(), [f]truncate(), syscall(), */



int main(int argc, char **argv) {
	char *self;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<1) {
		printf("Usage: %s\n", argv[0]);
		return 0;
	}
	
#if defined(HAVE_ENDUSERSHELL)
	printf("%s: endusershell(): call\n", self);
	endusershell();
	printf("%s: endusershell(): end\n", self);
#else
	/* endusershell() is not available on this OS platform !!! */
	printf("%s: endusershell() is not available on this OS platform !!!\n", self);
#endif
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/posix/endusershell

program wyświetli stosowne informacje o sposobie działania:

endusershell: endusershell(): call
endusershell: endusershell(): end

#top getegid¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji getegid() znajduje się w pliku nagłówkowym unistd.h.
Deklaracja funkcji getegid() jest następująca:

/* Get the effective group ID of the calling process.  */
extern __gid_t getegid (void) __THROW;

Powiązane:
getegid(), geteuid(), getgid(), getuid(), setgeid(), seteuid(), setgid(), setsid(), setuid(),

Opis:

Funkcja getegid() zwraca efektywny identyfikator grupy dla procesu wywołującego funkcję.

Argumenty:
Funkcja nie przyjmuje żadnych argumentów.

Zwracana wartość:
__gid_t - efektywny identyfikator grupy dla procesu wywołującego funkcję.

#top geteuid¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji geteuid() znajduje się w pliku nagłówkowym unistd.h.
Deklaracja funkcji geteuid() jest następująca:

/* Get the effective user ID of the calling process.  */
extern __uid_t geteuid (void) __THROW;

Powiązane:
getegid(), geteuid(), getgid(), getuid(), setgeid(), seteuid(), setgid(), setsid(), setuid(),

Opis:

Funkcja geteuid() zwraca efektywny identyfikator użytkownika dla procesu wywołującego funkcję.

Argumenty:
Funkcja nie przyjmuje żadnych argumentów.

Zwracana wartość:
__uid_t - efektywny identyfikator użytkownika dla procesu wywołującego funkcję.

#top getgid¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji getgid() znajduje się w pliku nagłówkowym unistd.h.
Deklaracja funkcji getgid() jest następująca:

/* Get the real group ID of the calling process.  */
extern __gid_t getgid (void) __THROW;

Powiązane:
getegid(), geteuid(), getgid(), getuid(), setgeid(), seteuid(), setgid(), setsid(), setuid(),

Opis:

Funkcja getgid() zwraca rzeczywisty identyfikator grupy dla procesu wywołującego funkcję.

Argumenty:
Funkcja nie przyjmuje żadnych argumentów.

Zwracana wartość:
__gid_t - rzeczywisty identyfikator grupy dla procesu wywołującego funkcję.

#top getgrent¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji getgrent() znajduje się w pliku nagłówkowym grp.h.
Deklaracja funkcji getgrent() jest następująca:

* Read an entry from the group-file stream, opening it if necessary.

   This function is a possible cancellation point and therefore not
   marked with __THROW.  */
extern struct group *getgrent (void);

Powiązane:
endgrent(), getgrent(), getgrgid(), getgrnam(), setgrent(),

Opis:

Funkcja getgrent() zwraca wskaźnik do struktury struct group zawierającej informacje dotyczące grupy użytkowników oraz informacje dotyczące użytkowników należących do danej grupy. W przypadku gdy w kolejnych wywołaniach funkcji zwrócone zostały już wszystkie informacje dotyczące wszystkich grup w systemie zamiast wskaźnika zwracany jest NULL.

Argumenty:
Funkcja nie przyjmuje żadnych argumentów.

Zwracana wartość:
struct group * - wskaźnik do struktury struct group zawierającej informacje dotyczące grupy użytkowników oraz informacje dotyczące użytkowników należących do danej grupy.

Example:
zawartość pliku getgrent.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
  #define WIN32_LEAN_AND_MEAN
#else
  #include <grp.h>         /* for gid_t, struct group, getgrent(), putgrent(), getgrgid(), getgrnam(), */
#endif



int main(int argc, char **argv) {
	char *self;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
#else
	struct group *groupptr;
	int i;
#endif
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<1) {
		printf("Usage: %s\n", argv[0]);
		return 0;
	}
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	/* setgrent() is not available on this OS platform !!! */
	printf("%s: setgrent() is not available on this OS platform !!!\n", self);
	
	/* getgrent() is not available on this OS platform !!! */
	printf("%s: getgrent() is not available on this OS platform !!!\n", self);
	
	/* endgrent() is not available on this OS platform !!! */
	printf("%s: endgrent() is not available on this OS platform !!!\n", self);
#else
	
	setgrent();
	
	while (1) {
		groupptr=getgrent();
		if (groupptr!=NULL) {
			printf("%s: groupptr=getgrent(): groupptr=%p if (groupptr!=NULL): Successful getgrent().\n", self, (void*)groupptr);
			printf("%s: groupptr=getgrent(): groupptr->gr_name=%s groupptr->gr_passwd=%s groupptr->gr_gid=%d\n", self, groupptr->gr_name, groupptr->gr_passwd, groupptr->gr_gid);
			if (groupptr->gr_mem[0]) printf("%s: groupptr=getgrent(): groupptr->gr_name=%s", self, groupptr->gr_name);
			for (i=0;groupptr->gr_mem[i]!=NULL;i++) {
				printf(" groupptr->gr_mem[%d]=%s", i, groupptr->gr_mem[i]);
				if (groupptr->gr_mem[i+1]!=NULL) printf(",");
			}
			if (groupptr->gr_mem[0]) printf("\n");
		} else {
			break;
		}
	}
	
	endgrent();
	
#endif
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/posix/getgrent

program wyświetli stosowne informacje o sposobie działania:

getgrent: groupptr=getgrent(): groupptr=0x2428e4 if (groupptr!=NULL): Successful getgrent().
getgrent: groupptr=getgrent(): groupptr->gr_name=root groupptr->gr_passwd=x groupptr->gr_gid=0
getgrent: groupptr=getgrent(): groupptr->gr_name=root groupptr->gr_mem[0]=root
getgrent: groupptr=getgrent(): groupptr=0x2428e4 if (groupptr!=NULL): Successful getgrent().
getgrent: groupptr=getgrent(): groupptr->gr_name=bin groupptr->gr_passwd=x groupptr->gr_gid=1
getgrent: groupptr=getgrent(): groupptr->gr_name=bin groupptr->gr_mem[0]=root, groupptr->gr_mem[1]=bin, groupptr->gr_mem[2]=daemon
getgrent: groupptr=getgrent(): groupptr=0x2428e4 if (groupptr!=NULL): Successful getgrent().
getgrent: groupptr=getgrent(): groupptr->gr_name=daemon groupptr->gr_passwd=x groupptr->gr_gid=2
getgrent: groupptr=getgrent(): groupptr->gr_name=daemon groupptr->gr_mem[0]=root, groupptr->gr_mem[1]=bin, groupptr->gr_mem[2]=daemon
getgrent: groupptr=getgrent(): groupptr=0x2428e4 if (groupptr!=NULL): Successful getgrent().
getgrent: groupptr=getgrent(): groupptr->gr_name=sys groupptr->gr_passwd=x groupptr->gr_gid=3
getgrent: groupptr=getgrent(): groupptr->gr_name=sys groupptr->gr_mem[0]=root, groupptr->gr_mem[1]=bin, groupptr->gr_mem[2]=adm
getgrent: groupptr=getgrent(): groupptr=0x2428e4 if (groupptr!=NULL): Successful getgrent().
getgrent: groupptr=getgrent(): groupptr->gr_name=adm groupptr->gr_passwd=x groupptr->gr_gid=4
getgrent: groupptr=getgrent(): groupptr->gr_name=adm groupptr->gr_mem[0]=root, groupptr->gr_mem[1]=adm, groupptr->gr_mem[2]=daemon, groupptr->gr_mem[3]=user, groupptr->gr_mem[4]=sp
getgrent: groupptr=getgrent(): groupptr=0x2428e4 if (groupptr!=NULL): Successful getgrent().
[...]

#top getgrgid¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji getgrgid() znajduje się w pliku nagłówkowym grp.h.
Deklaracja funkcji getgrgid() jest następująca:

/* Search for an entry with a matching group ID.

   This function is a possible cancellation point and therefore not
   marked with __THROW.  */
extern struct group *getgrgid (__gid_t __gid);

Powiązane:
endgrent(), getgrent(), getgrgid(), getgrnam(), setgrent(),

Opis:

Funkcja getgrgid() przeszukuje "bazy danych" zawierającej informacje dotyczące grup użytkowników w systemie oraz grup do których użytkownicy należą w poszukiwaniu grupy o identyfikatorze podanym w argumencie wywołania __gid i wskaźnik do struktury struct group zawierającej informacje dotyczące grupy użytkowników oraz informacje dotyczące użytkowników należących do danej grupy. W przypadku gdy grupa o podanym indentyfikatorze nie zostanie znaleziona zwracany jest wskaźnik NULL. Informacje dotyczące użytkowników w systemie może być przechowywana jest w pliku tekstowym :etc/group, w bazie Network Information Service (NIS) lub bazie Lightweight Directory Access Protocol (LDAP).

Argumenty:
__gid_t __gid - identyfikator (gid) grupy poszukiwanej w "bazach danych".

Zwracana wartość:
struct group * - wskaźnik do struktury struct group zawierającej informacje dotyczące grupy użytkowników oraz informacje dotyczące użytkowników należących do danej grupy.

#top getgrnam¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji getgrnam() znajduje się w pliku nagłówkowym grp.h.
Deklaracja funkcji getgrnam() jest następująca:

/* Search for an entry with a matching group name.

   This function is a possible cancellation point and therefore not
   marked with __THROW.  */
extern struct group *getgrnam (__const char *__name);

Powiązane:
endgrent(), getgrent(), getgrgid(), getgrnam(), setgrent(),

Opis:

Funkcja getgrnam() przeszukuje "bazy danych" zawierającej informacje dotyczące grup użytkowników w systemie oraz grup do których użytkownicy należą w poszukiwaniu grupy o nazwie podanej w argumencie wywołania __name i zwraca wskaźnik do struktury struct group zawierającej informacje dotyczące grupy użytkowników oraz informacje dotyczące użytkowników należących do danej grupy. W przypadku gdy grupa o podanej nazwie nie zostanie znaleziona zwracany jest wskaźnik NULL. Informacje dotyczące użytkowników w systemie może być przechowywana jest w pliku tekstowym :etc/group, w bazie Network Information Service (NIS) lub bazie Lightweight Directory Access Protocol (LDAP).

Argumenty:
const char *__name - łańcuch znaków (wskaźnik do łańcucha znaków) zawierający nazwę grupy poszukiwanej w "bazach danych".

Zwracana wartość:
struct group * - wskaźnik do struktury struct group zawierającej informacje dotyczące grupy użytkowników oraz informacje dotyczące użytkowników należących do danej grupy.

Example:
zawartość pliku getgrnam.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkstemp(), mkdtemp(), system(), realpath(), abs(), labs(), llabs(), getloadavg(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
  #define WIN32_LEAN_AND_MEAN
#else
  #include <grp.h>         /* for gid_t, struct group, getgrent(), putgrent(), getgrgid(), getgrnam(), */
#endif



int main(int argc, char **argv) {
	char *self;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
#else
	struct group *groupptr;
	gid_t groupgid;
	int i;
#endif
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<3) {
		printf("Usage: %s <username>\n", argv[0]);
		printf("Examples:\n");
		printf("       %s root 0\n", argv[0]);
		printf("       %s bin 1\n", argv[0]);
		printf("       %s daemon 2\n", argv[0]);
		printf("       %s adm 4\n", argv[0]);
		return 0;
	}
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	/* getgrnam() is not available on this OS platform !!! */
	printf("%s: getgrnam() is not available on this OS platform !!!\n", self);
#else
	groupptr=getgrnam(argv[1]);
	if (groupptr!=NULL) {
		printf("%s: groupptr=getgrnam(argv[1]=%s): groupptr=%p if (groupptr!=NULL): groupptr->gr_name=%s groupptr->gr_passwd=%s groupptr->gr_gid=%d\n", self, argv[1], (void*)groupptr, groupptr->gr_name, groupptr->gr_passwd, groupptr->gr_gid);
		if (groupptr->gr_mem[0]) printf("%s: groupptr=getgrnam(argv[1]=%s): groupptr->gr_name=%s", self, argv[1], groupptr->gr_name);
		for (i=0;groupptr->gr_mem[i]!=NULL;i++) {
			printf(" groupptr->gr_mem[%d]=%s", i, groupptr->gr_mem[i]);
			if (groupptr->gr_mem[i+1]!=NULL) printf(",");
		}
		if (groupptr->gr_mem[0]) printf("\n");
	} else {
		printf("%s: groupptr=getgrnam(argv[1]=%s): groupptr=%p if (groupptr!=NULL): else: Entry '%s' does not exists !!!\n", self, argv[1], (void*)groupptr, argv[1]);
	}
#endif
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	/* getgrgid() is not available on this OS platform !!! */
	printf("%s: getgrgid() is not available on this OS platform !!!\n", self);
#else
	groupgid=atoi(argv[2]);
	groupptr=getgrgid(groupgid);
	if (groupptr!=NULL) {
		printf("%s: groupptr=getgrgid(groupgid=%d): groupptr=%p if (groupptr!=NULL): groupptr->gr_name=%s groupptr->gr_passwd=%s groupptr->gr_gid=%d\n", self, groupgid, (void*)groupptr, groupptr->gr_name, groupptr->gr_passwd, groupptr->gr_gid);
		if (groupptr->gr_mem[0]) printf("%s: groupptr=getgrgid(groupgid=%d): groupptr->gr_name=%s", self, groupgid, groupptr->gr_name);
		for (i=0;groupptr->gr_mem[i]!=NULL;i++) {
			printf(" groupptr->gr_mem[%d]=%s", i, groupptr->gr_mem[i]);
			if (groupptr->gr_mem[i+1]!=NULL) printf(",");
		}
		if (groupptr->gr_mem[0]) printf("\n");
	} else {
		printf("%s: groupptr=getgrgid(groupgid=%d): groupptr=%p if (groupptr!=NULL): else: Entry '%d' does not exists !!!\n", self, groupgid, (void*)groupptr, groupgid);
	}
#endif
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/posix/getgrnam

program wyświetli informacje o sposobie uruchamiania programu:

Usage: /home/local/code/ansiccode/posix/getgrnam <username>
Examples:
       /home/local/code/ansiccode/posix/getgrnam root 0
       /home/local/code/ansiccode/posix/getgrnam bin 1
       /home/local/code/ansiccode/posix/getgrnam daemon 2
       /home/local/code/ansiccode/posix/getgrnam adm 4

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

/home/local/code/ansiccode/posix/getgrnam root 0
/home/local/code/ansiccode/posix/getgrnam bin 1
/home/local/code/ansiccode/posix/getgrnam daemon 2
/home/local/code/ansiccode/posix/getgrnam adm 4

rezultat będzie zależny od podanych argumentów wywołania programu:

getgrnam: groupptr=getgrnam(argv[1]=root): groupptr=0x242914 if (groupptr!=NULL): groupptr->gr_name=root groupptr->gr_passwd=x groupptr->gr_gid=0
getgrnam: groupptr=getgrnam(argv[1]=root): groupptr->gr_name=root groupptr->gr_mem[0]=root
getgrnam: groupptr=getgrgid(groupgid=0): groupptr=0x2428fc if (groupptr!=NULL): groupptr->gr_name=root groupptr->gr_passwd=x groupptr->gr_gid=0
getgrnam: groupptr=getgrgid(groupgid=0): groupptr->gr_name=root groupptr->gr_mem[0]=root

getgrnam: groupptr=getgrnam(argv[1]=bin): groupptr=0x242914 if (groupptr!=NULL): groupptr->gr_name=bin groupptr->gr_passwd=x groupptr->gr_gid=1
getgrnam: groupptr=getgrnam(argv[1]=bin): groupptr->gr_name=bin groupptr->gr_mem[0]=root, groupptr->gr_mem[1]=bin, groupptr->gr_mem[2]=daemon
getgrnam: groupptr=getgrgid(groupgid=1): groupptr=0x2428fc if (groupptr!=NULL): groupptr->gr_name=bin groupptr->gr_passwd=x groupptr->gr_gid=1
getgrnam: groupptr=getgrgid(groupgid=1): groupptr->gr_name=bin groupptr->gr_mem[0]=root, groupptr->gr_mem[1]=bin, groupptr->gr_mem[2]=daemon

getgrnam: groupptr=getgrnam(argv[1]=daemon): groupptr=0x242914 if (groupptr!=NULL): groupptr->gr_name=daemon groupptr->gr_passwd=x groupptr->gr_gid=2
getgrnam: groupptr=getgrnam(argv[1]=daemon): groupptr->gr_name=daemon groupptr->gr_mem[0]=root, groupptr->gr_mem[1]=bin, groupptr->gr_mem[2]=daemon
getgrnam: groupptr=getgrgid(groupgid=2): groupptr=0x2428fc if (groupptr!=NULL): groupptr->gr_name=daemon groupptr->gr_passwd=x groupptr->gr_gid=2
getgrnam: groupptr=getgrgid(groupgid=2): groupptr->gr_name=daemon groupptr->gr_mem[0]=root, groupptr->gr_mem[1]=bin, groupptr->gr_mem[2]=daemon

getgrnam: groupptr=getgrnam(argv[1]=adm): groupptr=0x480914 if (groupptr!=NULL): groupptr->gr_name=adm groupptr->gr_passwd=x groupptr->gr_gid=4
getgrnam: groupptr=getgrnam(argv[1]=adm): groupptr->gr_name=adm groupptr->gr_mem[0]=root, groupptr->gr_mem[1]=adm, groupptr->gr_mem[2]=daemon, groupptr->gr_mem[3]=user, groupptr->gr_mem[4]=sp
getgrnam: groupptr=getgrgid(groupgid=4): groupptr=0x4808fc if (groupptr!=NULL): groupptr->gr_name=adm groupptr->gr_passwd=x groupptr->gr_gid=4
getgrnam: groupptr=getgrgid(groupgid=4): groupptr->gr_name=adm groupptr->gr_mem[0]=root, groupptr->gr_mem[1]=adm, groupptr->gr_mem[2]=daemon, groupptr->gr_mem[3]=user, groupptr->gr_mem[4]=sp

#top gethostname¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji gethostname() znajduje się w pliku nagłówkowym unistd.h.
Deklaracja funkcji gethostname() jest następująca:

#if defined __USE_BSD || defined __USE_UNIX98
/* Put the name of the current host in no more than LEN bytes of NAME.
   The result is null-terminated if LEN is large enough for the full
   name and the terminator.  */
extern int gethostname (char *__name, size_t __len) __THROW __nonnull ((1));
#endif

Powiązane:
gethostname(), sethostname(),

Opis:

Funkcja getloadavg()

Argumenty:
char *__name -
size_t __len -

Zwracana wartość:
int -

Example:
zawartość pliku gethostname.c

SELECT ALL

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/posix/gethostname

program wyświetli stosowne informacje o sposobie działania:

#top getloadavg¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji getloadavg() znajduje się w pliku nagłówkowym stdlib.h.
Deklaracja funkcji getloadavg() jest następująca:

/* Put the 1 minute, 5 minute and 15 minute load averages into the first
   NELEM elements of LOADAVG.  Return the number written (never more than
   three, but may be less than NELEM), or -1 if an error occurred.  */
extern int getloadavg (double __loadavg[], int __nelem)
     __THROW __nonnull ((1));

Powiązane:

Opis:

Funkcja getloadavg()

Argumenty:
double __loadavg[] -
int __nelem -

Zwracana wartość:
int -

Example:
zawartość pliku getloadavg.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkdtemp(), system(), realpath(), abs(), llabs(), getloadavg() */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */



int main(int argc, char **argv) {
	char *self;
#if defined(HAVE_GETLOADAVG)
	int result;
	double loadavg[5];
#endif
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<1) {
		printf("Usage: %s\n", argv[0]);
		return 0;
	}
	
#if defined(HAVE_GETLOADAVG)
	result=getloadavg(loadavg, (int)( sizeof(loadavg)/sizeof(double) ));
	printf("%s: result=getloadavg(loadavg, (int)( sizeof(loadavg)/sizeof(double) )): result=%d\n", self, result);
	
	if (result>=1) printf("%s: loadavg[0]=%f\n", self, loadavg[0]);
	if (result>=2) printf("%s: loadavg[1]=%f\n", self, loadavg[1]);
	if (result>=3) printf("%s: loadavg[2]=%f\n", self, loadavg[2]);
#else
	/* getloadavg() is not available on this OS platform !!! */
	printf("%s: getloadavg() is not available on this OS platform !!!\n", self);
#endif
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/posix/getloadavg

program wyświetli stosowne informacje o sposobie działania:

getloadavg: result=getloadavg(loadavg, (int)( sizeof(loadavg)/sizeof(double) )): result=3
getloadavg: loadavg[0]=0.510000
getloadavg: loadavg[1]=0.610000
getloadavg: loadavg[2]=0.600000

#top getlogin¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji getlogin() znajduje się w pliku nagłówkowym unistd.h.
Deklaracja funkcji getlogin() jest następująca:

/* Return the login name of the user.

   This function is a possible cancellation points and therefore not
   marked with __THROW.  */
extern char *getlogin (void);

Powiązane:
getlogin(), getpass(), setlogin(),

Opis:

Funkcja getlogin() zwraca nazwę użytkownika procesu wywołującego niniejszą funkcję.

Argumenty:
Funkcja nie przyjmuje żadnych argumentów.

Zwracana wartość:
char * - łańcuch znaków (wskaźnik do łańcucha znaków) zawierający nazwę użytkownika procesu wywołującego niniejszą funkcję.

Example:
zawartość pliku getlogin.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <unistd.h>        /* for R_OK, W_OK, X_OK, F_OK, environ, access(), lseek(), close(), read(), write(), pipe(), alarm(), sleep(), ualarm(), usleep(), pause(), chown(), chdir(), getcwd(), */
                           /* for exec[...](), nice(), getpid(), getppid(), setpgid(), setsid(), getsid(), getuid(), geteuid(). getgid(), getegid(), setuid(), seteuid(), setgid(), setegid(), fork(), */
                           /* for link(), symlink(), readlink(), unlink(), rmdir(), getlogin(), setlogin(), gethostname(), sethostname(), daemon(), chroot(), getpass(), [f]sync(), [f]truncate(), syscall(), */



int main(int argc, char **argv) {
	char *self;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
#else
	char *strlogin;
#endif
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<1) {
		printf("Usage: %s\n", argv[0]);
		return 0;
	}
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	/* getlogin() is not available on this OS platform !!! */
	printf("%s: getlogin() is not available on this OS platform !!!\n", self);
#else
	strlogin=getlogin();
	printf("%s: strlogin=getlogin(): strlogin=|%s|\n", self, strlogin);
#endif
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/posix/getlogin

program wyświetli stosowne informacje o sposobie działania:

getlogin: strlogin=getlogin(): strlogin=|user|

#top getpass¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji getpass() znajduje się w pliku nagłówkowym unistd.h.
Deklaracja funkcji getpass() jest następująca:

/* Prompt with PROMPT and read a string from the terminal without echoing.
   Uses /dev/tty if possible; otherwise stderr and stdin.  */
extern char *getpass (__const char *__prompt) __nonnull ((1));

Powiązane:
getlogin(), getpass(), setlogin(),

Opis:

Funkcja getpass() otwiera terminal skorelowany z procesem, wyświetla (zapisuje) podany w argumencie __prompt ciąg znaków zakończony zerem jako znak "zachęty" w oczekiwaniu na wpisanie ciągu znaków, wyłącza wyświetlanie wpisywanych (wczytywanych) znaków, odczytuje znaki z otwartego terminala kontrolnego aż do znaku nowej linii lub znaku końca EOF, na koniec przywraca ustawienia termiana, zamyka terminal i zwraca łańuch znaków (wskaźnik do łańcucha znaków) zawierający wczytany z terminala ciąg znaków.

Argumenty:
const char *__prompt - łańuch znaków (wskaźnik do łańcucha znaków) wyświetlany na terminalu jako znak "zachęty" w oczekiwaniu na wpisanie ciągu znaków.

Zwracana wartość:
char * - łańuch znaków (wskaźnik do łańcucha znaków) odczytany z terminala.

Example:
zawartość pliku getpass.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <unistd.h>        /* for R_OK, W_OK, X_OK, F_OK, environ, access(), lseek(), close(), read(), write(), pipe(), alarm(), sleep(), ualarm(), usleep(), pause(), chown(), chdir(), getcwd(), */
                           /* for exec[...](), nice(), getpid(), getppid(), setpgid(), setsid(), getsid(), getuid(), geteuid(). getgid(), getegid(), setuid(), seteuid(), setgid(), setegid(), fork(), */
                           /* for link(), symlink(), readlink(), unlink(), rmdir(), getlogin(), setlogin(), gethostname(), sethostname(), daemon(), chroot(), getpass(), [f]sync(), [f]truncate(), syscall(), */



int main(int argc, char **argv) {
	char *self;
#if defined(HAVE_GETPASS)
	char *password;
#endif
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage: %s <prompt-string>\n", argv[0]);
		return 0;
	}
	
#if defined(HAVE_GETPASS)
	password=getpass(argv[1]);
	printf("%s: password=getpass(argv[1]=%s): password='%s'\n", self, argv[1], password);
#else
	/* getpass() is not available on this OS platform !!! */
	printf("%s: getpass() is not available on this OS platform !!!\n", self);
#endif
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/posix/getpass

program wyświetli informacje o sposobie uruchamiania programu:

Usage: /home/local/code/ansiccode/posix/getpass <prompt-string>

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

/home/local/code/ansiccode/posix/getpass "Enter password (it will be not printed on screen): "

po wyświetleniu podanego jako argument prompt tekstu należy wpisać dowolny ciąg znaków (w zamierzeniu powinno to być hasło, a nastęnie nacisnąc klawisz Enter),
rezultat będzie zależny od podanych argumentów wywołania programu:

Enter password (it will be not printed on screen):
getpass: password=getpass(argv[1]=Enter password (it will be not printed on screen): ): password='password'

#top getpgid¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji getpgid() znajduje się w pliku nagłówkowym unistd.h.
Deklaracja funkcji getpgid() jest następująca:

/* Get the process group ID of process PID.  */
extern __pid_t getpgid (__pid_t __pid) __THROW;

Powiązane:
getpgid(), getpgrp(), setpgid(), setpgrp(),

Opis:

Funkcja getpgid()

Argumenty:
__pid_t __pid -

Zwracana wartość:
__pid_t -

Example:
zawartość pliku getpgid.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkstemp(), mkdtemp(), system(), realpath(), abs(), labs(), llabs(), getloadavg(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <unistd.h>        /* for R_OK, W_OK, X_OK, F_OK, environ, access(), lseek(), close(), read(), write(), pipe(), alarm(), sleep(), ualarm(), usleep(), pause(), chown(), chdir(), getcwd(), */
                           /* for exec[...](), nice(), getpid(), getppid(), setpgid(), setsid(), getsid(), getuid(), geteuid(). getgid(), getegid(), setuid(), seteuid(), setgid(), setegid(), fork(), */
                           /* for link(), symlink(), readlink(), unlink(), rmdir(), getlogin(), setlogin(), gethostname(), sethostname(), daemon(), chroot(), getpass(), [f]sync(), [f]truncate(), syscall(), */
#include <errno.h>         /* for errno constant, error constants, */



int main(int argc, char **argv) {
	char *self;
	pid_t pid;
	pid_t pgid;
#if defined(HAVE_SETPGID)
	int result;
#endif
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<3) {
		printf("Usage: %s <pid> <pgid>\n", argv[0]);
		printf("Examples:\n");
		printf("Usage: %s $$ $$\n", argv[0]);
		return 0;
	}
	
	pid=atoi(argv[1]);
#if defined(HAVE_GETPGID)
	pgid=getpgid(pid);
	printf("%s: pgid=getpgid(pid=%d); pgid=%d\n", self, (int)pid, (int)pgid);
#else
	/* getpgid() is not available on this OS platform !!! */
	printf("%s: getpgid() is not available on this OS platform !!!\n", self);
#endif
	
	pid=atoi(argv[1]);
	pgid=atoi(argv[2]);
#if defined(HAVE_SETPGID)
	result=setpgid(pid, pgid);
	if (result>=0) printf("%s: result=setpgid(pid=%d, pgid=%d); result=%d if (result>=0): Successful setpgrp().\n", self, (int)pid, (int)pgid, result);
	else           printf("%s: result=setpgid(pid=%d, pgid=%d); result=%d if (result>=0): else: Unable to setpgrp(), Reason=%d:%s\n", self, (int)pid, (int)pgid, result, errno, strerror(errno));
#else
	/* setpgid() is not available on this OS platform !!! */
	printf("%s: setpgid() is not available on this OS platform !!!\n", self);
#endif
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/posix/getpgid

program wyświetli informacje o sposobie uruchamiania programu:

Usage: /home/local/code/ansiccode/posix/getpgid <pid> <pgid>
Examples
       /home/local/code/ansiccode/posix/getpgid $$ $$

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

/home/local/code/ansiccode/posix/getpgid $$ $$

rezultat będzie zależny od podanych argumentów wywołania programu:

/home/local/code/ansiccode/posix/getpgid: pgid=getpgid(pid=10171); pgid=10171
/home/local/code/ansiccode/posix/getpgid: result=setpgid(pid=10171, pgid=10171); result=-1 if (result>=0): else: Unable to setpgrp, Reason=3:No such process

#top getpgrp¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji getpgrp() znajduje się w pliku nagłówkowym unistd.h.
Deklaracja funkcji getpgrp() jest następująca:

/* Get the process group ID of the calling process.
   This function is different on old BSD. */
extern __pid_t getpgrp (void) __THROW;

Powiązane:
getpgid(), getpgrp(), setpgid(), setpgrp(),

Opis:

Funkcja getpgrp()

Argumenty:
Funkcja nie przyjmuje żadnych argumentów.

Zwracana wartość:
__pid_t -

Example:
zawartość pliku getpgrp.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <unistd.h>        /* for R_OK, W_OK, X_OK, F_OK, environ, access(), lseek(), close(), read(), write(), pipe(), alarm(), sleep(), ualarm(), usleep(), pause(), chown(), chdir(), getcwd(), */
                           /* for exec[...](), nice(), getpid(), getppid(), setpgid(), setsid(), getsid(), getuid(), geteuid(). getgid(), getegid(), setuid(), seteuid(), setgid(), setegid(), fork(), */
                           /* for link(), symlink(), readlink(), unlink(), rmdir(), getlogin(), setlogin(), gethostname(), sethostname(), daemon(), chroot(), getpass(), [f]sync(), [f]truncate(), syscall(), */
#include <errno.h>         /* for errno constant, error constants, */



int main(int argc, char **argv) {
	char *self;
#if defined(HAVE_SETPGRP_2ARGS) || defined(HAVE_GETPGRP_2ARGS)
	pid_t mypid;
	int result;
#endif
#if defined(HAVE_GETPGRP_0ARGS) || defined(HAVE_SETPGRP_0ARGS)
	pid_t mygrp;
	int result;
#endif
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<1) {
		printf("Usage: %s\n", argv[0]);
		return 0;
	}
	
#if defined(HAVE_GETPGRP_0ARGS)
	mygrp=getpgrp();
	printf("%s: result=getpgrp(); mygrp=%d\n", self, mygrp);
	result=setpgrp();
	if (result>=0) printf("%s: result=setpgrp(); result=%d if (result>=0): Successful setpgrp().\n", self, result);
	else           printf("%s: result=setpgrp(); result=%d if (result>=0): else: Unable to setpgrp(), Reason=%d:%s\n", self, result, errno, strerror(errno));
#else
	/* getpgrp() is not available on this OS platform !!! */
	printf("%s: getpgrp() is not available on this OS platform !!!\n", self);
#endif

#if defined(HAVE_GETPGRP_2ARGS)
	mypid=getpid();
	mygrp=getpgrp();
	printf("%s: result=getpgrp(); mygrp=%d\n", self, mygrp);
	result=setpgrp(mypid, mygrp);
	if (result>=0) printf("%s: result=setpgrp(mypid=%d, mygrp=%d); result=%d if (result>=0): Successful setpgrp().\n", self, (int)mypid, (int)mygrp, result);
	else           printf("%s: result=setpgrp(mypid=%d, mygrp=%d); result=%d if (result>=0): else: Unable to setpgrp(), Reason=%d:%s\n", self, (int)mypid, (int)mygrp, result, errno, strerror(errno));
#else
	/* getpgrp() is not available on this OS platform !!! */
	printf("%s: getpgrp() is not available on this OS platform !!!\n", self);
#endif
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/posix/getpgrp

program wyświetli stosowne informacje o sposobie działania:

getpgrp: result=getpgrp(); mygrp=302
getpgrp: result=setpgrp(); result=0 if (result>=0): Successful setpgrp().

#top getpid¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji getpid() znajduje się w pliku nagłówkowym unistd.h.
Deklaracja funkcji getpid() jest następująca:

/* Get the process ID of the calling process.  */
extern __pid_t getpid (void) __THROW;

Powiązane:
getpid(), getppid(), getsid(), kill(),

Opis:

Funkcja getpid() zwraca identyfikator (PID) procesu dla procesu wywołującego funkcję.

Argumenty:
Funkcja nie przyjmuje żadnych argumentów.

Zwracana wartość:
__pid_t - identyfikator (PID) procesu dla procesu wywołującego funkcję.

Example:
zawartość pliku getpid.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <unistd.h>        /* for R_OK, W_OK, X_OK, F_OK, environ, access(), lseek(), close(), read(), write(), pipe(), alarm(), sleep(), ualarm(), usleep(), pause(), chown(), chdir(), getcwd(), */
                           /* for exec[...](), nice(), getpid(), getppid(), setpgid(), setsid(), getsid(), getuid(), geteuid(). getgid(), getegid(), setuid(), seteuid(), setgid(), setegid(), fork(), */
                           /* for link(), symlink(), readlink(), unlink(), rmdir(), getlogin(), setlogin(), gethostname(), sethostname(), daemon(), chroot(), getpass(), [f]sync(), [f]truncate(), syscall(), */

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
  #include <windows.h>     /* for windef.h, wincon.h, winbase.h, winuser.h, winver.h, winsock.h, */
  #include <tlhelp32.h>    /* for (typedef struct) PROCESSENTRY32, Process32First(), Process32Next(), */
#endif



#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
pid_t getppid() {
	pid_t myppid;
	
	HANDLE handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
	PROCESSENTRY32 pe;
	pid_t mypid;
	
	myppid=-1;
	memset(&pe, 0x00, sizeof(PROCESSENTRY32));
	pe.dwSize = sizeof(PROCESSENTRY32);
	/*mypid = GetCurrentProcessId();*/
	mypid=getpid();
	if (Process32First(handle,&pe)) {
		do {
			if ((pid_t)pe.th32ProcessID == mypid) {
				/*printf("PID: %i; PPID: %i\n", pid, (int)pe.th32ParentProcessID);*/
				myppid=pe.th32ParentProcessID;
			}
		} while (Process32Next(handle,&pe));
	}
	CloseHandle(handle);
	return myppid;
}
#endif



int main(int argc, char **argv) {
	char *self;
	pid_t mypid;
	pid_t myppid;
	pid_t mysid;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<1) {
		printf("Usage: %s\n", argv[0]);
		return 0;
	}
	
	printf("%s: mypid=getpid():\n", self);
	mypid=getpid();
	printf("%s: mypid=getpid(): mypid=%d\n", self, (int)mypid);
	
	printf("%s: mypid=getppid():\n", self);
	myppid=getppid();
	printf("%s: mypid=getppid(): myppid=%d\n", self, (int)myppid);
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)	
	/* getsid() is not available on this OS platform !!! */
	printf("%s: getsid() is not available on this OS platform !!!\n", self);
	mysid=-1;
#else
	printf("%s: mysid=getsid(mypid=%d):\n", self, (int)mypid);
	mysid=getsid(mypid);
	printf("%s: mysid=getsid(mypid=%d): mysid=%d\n", self, (int)mypid, (int)mysid);
#endif
	printf("%s: mypid=%d myppid=%d mysid=%d\n", self, (int)mypid, (int)myppid, (int)mysid);
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/posix/getpid

program wyświetli stosowne informacje o sposobie działania:

getpid: mypid=getpid():
getpid: mypid=getpid(): mypid=27216
getpid: mypid=getppid():
getpid: mypid=getppid(): myppid=6823
getpid: mysid=getsid(mypid=27216):
getpid: mysid=getsid(mypid=27216): mysid=6814
getpid: mypid=27216 myppid=6823 mysid=6814

#top getppid¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji getppid() znajduje się w pliku nagłówkowym unistd.h.
Deklaracja funkcji getppid() jest następująca:

/* Get the process ID of the calling process's parent.  */
extern __pid_t getppid (void) __THROW;

Powiązane:
getpid(), getppid(), getsid(), kill(),

Opis:

Funkcja getppid() zwraca identyfikator (PPID) procesu rodzica dla procesu wywołującego funkcję.

Argumenty:
Funkcja nie przyjmuje żadnych argumentów.

Zwracana wartość:
__pid_t - identyfikator (PPID) procesu rodzica dla procesu wywołującego funkcję.

#top getpwent¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji getpwent() znajduje się w pliku nagłówkowym pwd.h.
Deklaracja funkcji getpwent() jest następująca:

/* Read an entry from the password-file stream, opening it if necessary.

   This function is a possible cancellation point and therefore not
   marked with __THROW.  */
extern struct passwd *getpwent (void);

Powiązane:
endpwent(), getpwent(), getpwnam(), getpwuid(), setpwent(),

Opis:

Funkcja getpwent() zwraca wskaźnik do struktury struct passwd zawierającej informacje dotyczące użytkowników. W przypadku gdy w kolejnych wywołaniach funkcji zwrócone zostały już wszystkie informacje dotyczące wszystkich użytkowników w systemie zamiast wskaźnika zwracany jest NULL.

Argumenty:
Funkcja nie przyjmuje żadnych argumentów.

Zwracana wartość:
struct passwd * - wskaźnik do struktury struct passwd zawierającej informacje dotyczące użytkowników.

Example:
zawartość pliku getpwent.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <errno.h>         /* for errno variable, error constants, */

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
  #define WIN32_LEAN_AND_MEAN
#else
  #include <pwd.h>         /* for uid_t, gid_t, struct passwd, getpwent(), getpwuid(), putpwent(), getpwnam(), */
#endif



int main(int argc, char **argv) {
	char *self;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
#else
	struct passwd *passwdptr;
#endif
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<1) {
		printf("Usage: %s\n", argv[0]);
		return 0;
	}
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	/* setpwent() is not available on this OS platform !!! */
	printf("%s: setpwent() is not available on this OS platform !!!\n", self);
	
	/* getpwent() is not available on this OS platform !!! */
	printf("%s: getpwent() is not available on this OS platform !!!\n", self);
	
	/* endpwent() is not available on this OS platform !!! */
	printf("%s: endpwent() is not available on this OS platform !!!\n", self);
#else
	
	setpwent();
	
	while (1) {
		passwdptr=getpwent();
		if (passwdptr!=NULL) {
			printf("%s: passwdptr=getpwent(): passwdptr=%p if (passwdptr!=NULL): Successful getpwent().\n", self, (void*)passwdptr);
			printf("%s: passwdptr=getpwent(): passwdptr->pw_name=%s passwdptr->pw_passwd=%s passwdptr->pw_uid=%d passwdptr->pw_gid=%d passwdptr->pw_gecos=%s passwdptr->pw_dir=%s passwdptr->pw_shell=%s\n", self, passwdptr->pw_name, passwdptr->pw_passwd, passwdptr->pw_uid, passwdptr->pw_gid, passwdptr->pw_gecos, passwdptr->pw_dir, passwdptr->pw_shell);
		} else {
			break;
		}
	}
	
	endpwent();
	
#endif
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/posix/getpwent

program wyświetli stosowne informacje o sposobie działania:

getpwent: passwdptr=getpwent(): passwdptr=0x242970 if (passwdptr!=NULL): Successful getpwent().
getpwent: passwdptr=getpwent(): passwdptr->pw_name=root passwdptr->pw_passwd=x passwdptr->pw_uid=0 passwdptr->pw_gid=0 passwdptr->pw_gecos=root passwdptr->pw_dir=/root passwdptr->pw_shell=/bin/bash
getpwent: passwdptr=getpwent(): passwdptr=0x242970 if (passwdptr!=NULL): Successful getpwent().
getpwent: passwdptr=getpwent(): passwdptr->pw_name=bin passwdptr->pw_passwd=x passwdptr->pw_uid=1 passwdptr->pw_gid=1 passwdptr->pw_gecos=bin passwdptr->pw_dir=/bin passwdptr->pw_shell=/sbin/nologin
getpwent: passwdptr=getpwent(): passwdptr=0x242970 if (passwdptr!=NULL): Successful getpwent().
getpwent: passwdptr=getpwent(): passwdptr->pw_name=daemon passwdptr->pw_passwd=x passwdptr->pw_uid=2 passwdptr->pw_gid=2 passwdptr->pw_gecos=daemon passwdptr->pw_dir=/sbin passwdptr->pw_shell=/sbin/nologin
getpwent: passwdptr=getpwent(): passwdptr=0x242970 if (passwdptr!=NULL): Successful getpwent().
getpwent: passwdptr=getpwent(): passwdptr->pw_name=adm passwdptr->pw_passwd=x passwdptr->pw_uid=3 passwdptr->pw_gid=4 passwdptr->pw_gecos=adm passwdptr->pw_dir=/var/adm passwdptr->pw_shell=/sbin/nologin
getpwent: passwdptr=getpwent(): passwdptr=0x242970 if (passwdptr!=NULL): Successful getpwent().
[...]

#top getpwnam¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji getpwnam() znajduje się w pliku nagłówkowym pwd.h.
Deklaracja funkcji getpwnam() jest następująca:

/* Search for an entry with a matching username.

   This function is a possible cancellation point and therefore not
   marked with __THROW.  */
extern struct passwd *getpwnam (__const char *__name);

Powiązane:
endpwent(), getpwent(), getpwnam(), getpwuid(), setpwent(),

Opis:

Funkcja getpwnam() przeszukuje "bazy danych" zawierającej informacje dotyczące użytkowników w systemie w poszukiwaniu użytkownika o nazwie podanej w argumencie wywołania funkcji __name i zwraca wskaźnik do struktury struct passwd zawierającej informacje dotyczące poszukiwanego użytkownika. W przypadku gdy użytkownik o podanej nazwie nie zostanie znaleziony zwracany jest wskaźnik NULL. Informacje dotyczące użytkowników w systemie może być przechowywana jest w pliku tekstowym :etc/passwd, w bazie Network Information Service (NIS) lub bazie Lightweight Directory Access Protocol (LDAP).

Argumenty:
const char *__name - łańcuch znaków (wskaźnik do łańcucha znaków) zawierający nazwę użytkownika poszukiwanego w "bazach danych".

Zwracana wartość:
struct passwd * - wskaźnik do struktury struct passwd zawierającej informacje dotyczące poszukiwanego użytkownika.

Example:
zawartość pliku getpwnam.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkstemp(), mkdtemp(), system(), realpath(), abs(), labs(), llabs(), getloadavg(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
  #define WIN32_LEAN_AND_MEAN
#else
  #include <pwd.h>         /* for uid_t, gid_t, struct passwd, getpwent(), getpwuid(), putpwent(), getpwnam(), */
#endif



int main(int argc, char **argv) {
	char *self;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
#else
	struct passwd *passwdptr;
	uid_t passwduid;
#endif
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<3) {
		printf("Usage: %s <username> <useruid>\n", argv[0]);
		printf("Examples:\n");
		printf("       %s root 0\n", argv[0]);
		printf("       %s bin 1\n", argv[0]);
		printf("       %s daemon 2\n", argv[0]);
		printf("       %s adm 3\n", argv[0]);
		return 0;
	}
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	/* getpwnam() is not available on this OS platform !!! */
	printf("%s: getpwnam() is not available on this OS platform !!!\n", self);
#else
	passwdptr=getpwnam(argv[1]);
	if (passwdptr!=NULL) {
		printf("%s: passwdptr=getpwnam(argv[1]=%s): passwdptr=%p if (passwdptr!=NULL): passwdptr->pw_name=%s passwdptr->pw_passwd=%s passwdptr->pw_uid=%d passwdptr->pw_gid=%d passwdptr->pw_gecos=%s passwdptr->pw_dir=%s passwdptr->pw_shell=%s\n", self, argv[1], (void*)passwdptr, passwdptr->pw_name, passwdptr->pw_passwd, passwdptr->pw_uid, passwdptr->pw_gid, passwdptr->pw_gecos, passwdptr->pw_dir, passwdptr->pw_shell);
	} else {
		printf("%s: passwdptr=getpwnam(argv[1]=%s): passwdptr=%p if (passwdptr!=NULL): else: Entry '%s' does not exists !!!\n", self, argv[1], (void*)passwdptr, argv[1]);
	}
#endif
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	/* getpwuid() is not available on this OS platform !!! */
	printf("%s: getpwuid() is not available on this OS platform !!!\n", self);
#else
	passwduid=atoi(argv[2]);
	passwdptr=getpwuid(passwduid);
	if (passwdptr!=NULL) {
		printf("%s: passwdptr=getpwuid(passwduid=%d): passwdptr=%p if (passwdptr!=NULL): passwdptr->pw_name=%s passwdptr->pw_passwd=%s passwdptr->pw_uid=%d passwdptr->pw_gid=%d passwdptr->pw_gecos=%s passwdptr->pw_dir=%s passwdptr->pw_shell=%s\n", self, (int)passwduid, (void*)passwdptr, passwdptr->pw_name, passwdptr->pw_passwd, passwdptr->pw_uid, passwdptr->pw_gid, passwdptr->pw_gecos, passwdptr->pw_dir, passwdptr->pw_shell);
	} else {
		printf("%s: passwdptr=getpwuid(passwduid=%d): passwdptr=%p if (passwdptr!=NULL): else: Entry '%d' does not exists !!!\n", self, (int)passwduid, (void*)passwdptr, (int)passwduid);
	}
#endif
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/posix/getpwnam

program wyświetli informacje o sposobie uruchamiania programu:

Usage: /home/local/code/ansiccode/posix/getpwnam <username> <useruid>
Examples:
       /home/local/code/ansiccode/posix/getpwnam root 0
       /home/local/code/ansiccode/posix/getpwnam bin 1
       /home/local/code/ansiccode/posix/getpwnam daemon 2
       /home/local/code/ansiccode/posix/getpwnam adm 3

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

/home/local/code/ansiccode/posix/getpwnam root 0
/home/local/code/ansiccode/posix/getpwnam bin 1
/home/local/code/ansiccode/posix/getpwnam daemon 2
/home/local/code/ansiccode/posix/getpwnam adm 3

rezultat będzie zależny od podanych argumentów wywołania programu:

getpwnam: passwdptr=getpwnam(argv[1]=root): passwdptr=0x2e3994 if (passwdptr!=NULL): passwdptr->pw_name=root passwdptr->pw_passwd=x passwdptr->pw_uid=0 passwdptr->pw_gid=0 passwdptr->pw_gecos=root passwdptr->pw_dir=/root passwdptr->pw_shell=/bin/bash
getpwnam: passwdptr=getpwuid(passwduid=0): passwdptr=0x2e39b8 if (passwdptr!=NULL): passwdptr->pw_name=root passwdptr->pw_passwd=x passwdptr->pw_uid=0 passwdptr->pw_gid=0 passwdptr->pw_gecos=root passwdptr->pw_dir=/root passwdptr->pw_shell=/bin/bash

getpwnam: passwdptr=getpwnam(argv[1]=bin): passwdptr=0x242994 if (passwdptr!=NULL): passwdptr->pw_name=bin passwdptr->pw_passwd=x passwdptr->pw_uid=1 passwdptr->pw_gid=1 passwdptr->pw_gecos=bin passwdptr->pw_dir=/bin passwdptr->pw_shell=/sbin/nologin
getpwnam: passwdptr=getpwuid(passwduid=1): passwdptr=0x2429b8 if (passwdptr!=NULL): passwdptr->pw_name=bin passwdptr->pw_passwd=x passwdptr->pw_uid=1 passwdptr->pw_gid=1 passwdptr->pw_gecos=bin passwdptr->pw_dir=/bin passwdptr->pw_shell=/sbin/nologin

getpwnam: passwdptr=getpwnam(argv[1]=daemon): passwdptr=0x242994 if (passwdptr!=NULL): passwdptr->pw_name=daemon passwdptr->pw_passwd=x passwdptr->pw_uid=2 passwdptr->pw_gid=2 passwdptr->pw_gecos=daemon passwdptr->pw_dir=/sbin passwdptr->pw_shell=/sbin/nologin
getpwnam: passwdptr=getpwuid(passwduid=2): passwdptr=0x2429b8 if (passwdptr!=NULL): passwdptr->pw_name=daemon passwdptr->pw_passwd=x passwdptr->pw_uid=2 passwdptr->pw_gid=2 passwdptr->pw_gecos=daemon passwdptr->pw_dir=/sbin passwdptr->pw_shell=/sbin/nologin

getpwnam: passwdptr=getpwnam(argv[1]=adm): passwdptr=0x242994 if (passwdptr!=NULL): passwdptr->pw_name=adm passwdptr->pw_passwd=x passwdptr->pw_uid=3 passwdptr->pw_gid=4 passwdptr->pw_gecos=adm passwdptr->pw_dir=/var/adm passwdptr->pw_shell=/sbin/nologin
getpwnam: passwdptr=getpwuid(passwduid=3): passwdptr=0x2429b8 if (passwdptr!=NULL): passwdptr->pw_name=adm passwdptr->pw_passwd=x passwdptr->pw_uid=3 passwdptr->pw_gid=4 passwdptr->pw_gecos=adm passwdptr->pw_dir=/var/adm passwdptr->pw_shell=/sbin/nologin

#top getpwuid¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji getpwuid() znajduje się w pliku nagłówkowym pwd.h.
Deklaracja funkcji getpwuid() jest następująca:

/* Search for an entry with a matching user ID.

   This function is a possible cancellation point and therefore not
   marked with __THROW.  */
extern struct passwd *getpwuid (__uid_t __uid);

Powiązane:
endpwent(), getpwent(), getpwnam(), getpwuid(), setpwent(),

Opis:

Funkcja getpwuid() przeszukuje "bazy danych" zawierającej informacje dotyczące użytkowników w systemie w poszukiwaniu użytkownika o identyfikatorze podanym w argumencie wywołania funkcji __uid i zwraca wskaźnik do struktury struct passwd zawierającej informacje dotyczące poszukiwanego użytkownika. W przypadku gdy użytkownik o podanym identyfikatorze nie zostanie znaleziony zwracany jest wskaźnik NULL. Informacje dotyczące użytkowników w systemie może być przechowywana jest w pliku tekstowym :etc/passwd, w bazie Network Information Service (NIS) lub bazie Lightweight Directory Access Protocol (LDAP).

Argumenty:
__uid_t __uid - identyfikator (uid) użytkownika poszukiwanego w "bazach danych".

Zwracana wartość:
struct passwd * - wskaźnik do struktury struct passwd zawierającej informacje dotyczące poszukiwanego użytkownika.

#top getsid¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji getsid() znajduje się w pliku nagłówkowym unistd.h.
Deklaracja funkcji getsid() jest następująca:

/* Return the session ID of the given process.  */
extern __pid_t getsid (__pid_t __pid) __THROW;

Powiązane:
getpid(), getppid(), getsid(), kill(),

Opis:

Funkcja getsid()

Argumenty:
__pid_t __pid -

Zwracana wartość:
__pid_t -

#top getuid¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji getuid() znajduje się w pliku nagłówkowym unistd.h.
Deklaracja funkcji getuid() jest następująca:

/* Get the real user ID of the calling process.  */
extern __uid_t getuid (void) __THROW;

Powiązane:
getegid(), geteuid(), getgid(), getuid(), setgeid(), seteuid(), setgid(), setsid(), setuid(),

Opis:

Funkcja getuid() zwraca rzeczywisty identyfikator użytkownika dla procesu wywołującego funkcję.

Argumenty:
Funkcja nie przyjmuje żadnych argumentów.

Zwracana wartość:
__uid_t - rzeczywisty identyfikator użytkownika dla procesu wywołującego funkcję.

Example:
zawartość pliku getuid.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <unistd.h>        /* for R_OK, W_OK, X_OK, F_OK, environ, access(), lseek(), close(), read(), write(), pipe(), alarm(), sleep(), ualarm(), usleep(), pause(), chown(), chdir(), getcwd(), */
                           /* for exec[...](), nice(), getpid(), getppid(), setpgid(), setsid(), getsid(), getuid(), geteuid(). getgid(), getegid(), setuid(), seteuid(), setgid(), setegid(), fork(), */
                           /* for link(), symlink(), readlink(), unlink(), rmdir(), getlogin(), setlogin(), gethostname(), sethostname(), daemon(), chroot(), getpass(), [f]sync(), [f]truncate(), syscall(), */



int main(int argc, char **argv) {
	char *self;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
#else
	uid_t myuid;
	uid_t myeuid;
	gid_t mygid;
	gid_t myegid;
#endif
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<1) {
		printf("Usage: %s\n", argv[0]);
		return 0;
	}
	
	printf("DO using sudo or as root and then execute:\n");
	printf("------------------------------------------\n");
	printf("chown root:root %s\n", argv[0]);
	printf("chmod ug+s %s\n", argv[0]);
	printf("\n");
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	/* getuid() is not available on this OS platform !!! */
	printf("%s: getuid() is not available on this OS platform !!!\n", self);
	
	/* geteuid() is not available on this OS platform !!! */
	printf("%s: geteuid() is not available on this OS platform !!!\n", self);
	
	/* getgid() is not available on this OS platform !!! */
	printf("%s: getgid() is not available on this OS platform !!!\n", self);
	
	/* getegid() is not available on this OS platform !!! */
	printf("%s: getegid() is not available on this OS platform !!!\n", self);
#else
	myuid=getuid();
	printf("%s: myuid=getuid(): myuid=%d\n", self, myuid);
	
	myeuid=geteuid();
	printf("%s: myeuid=geteuid(): myeuid=%d\n", self, myeuid);
	
	mygid=getgid();
	printf("%s: mygid=getgid(): mygid=%d\n", self, mygid);
	
	myegid=getegid();
	printf("%s: myegid=getegid(): myegid=%d\n", self, myegid);
	
	printf("%s: myuid=%d myeuid=%d mygid=%d myegid=%d\n", self, myuid, myeuid, mygid, myegid);
#endif
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

zgodnie z informacją wyświetlaną przez program należy wykonać następujące polecenia jako root lub z użyciem sudo:

chown root:root /home/local/code/ansiccode/posix/getuid
chmod ug+s /home/local/code/ansiccode/posix/getuid

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/posix/getuid

program wyświetli stosowne informacje o sposobie działania:

DO using sudo or as root and then execute:
------------------------------------------
chown root:root /home/local/code/ansiccode/posix/geteuid
chmod ug+s /home/local/code/ansiccode/posix/geteuid

geteuid: myuid=getuid(): myuid=501
geteuid: myeuid=geteuid(), myeuid=0
geteuid: mygid=getgid(): mygid=100
geteuid: myegid=getegid(): myegid=0
geteuid: myuid=501 myeuid=0 mygid=100 myegid=0

Jak widać na powyższym przykładzie efektywny identyfikator użytkownika myeuid=0 oraz efektywny identyfikator grupy myegid=0, co wynika z faktu ls -l /home/local/code/ansiccode/posix/getuid, ls -n -l /home/local/code/ansiccode/posix/getuid

-rwsr-sr-x 1 root root 6001 paź 18 19:36 /home/local/code/ansiccode/posix/getuid*
-rwsr-sr-x 1 0 0 6001 paź 18 19:36 /home/local/code/ansiccode/posix/getuid*

że właścicielem programu jest użytkownik root oraz program posiada ustawione bity SETUID SETGID, czyli program uruchomiony przez dowolnego użytkownika będzie posiadać podwyższone uprawnienia.

#top getusershell¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji getusershell() znajduje się w pliku nagłówkowym unistd.h.
Deklaracja funkcji getusershell() jest następująca:

/* Successive calls return the shells listed in `/etc/shells'.  */
extern char *getusershell (void) __THROW;

Powiązane:
endusershell(), getusershell(), setusershell(),

Opis:

Funkcja getusershell() zwraca łańcuch znaków (wskaźnik do łańcucha znaków) zawierający informacje dotyczące powłok systemowych użytkowników posiadających konta w systemie. W przypadku gdy w kolejnych wywołaniach funkcji zwrócone zostały już wszystkie informacje dotyczące powłok systemowych użytkowników posiadających konta w systemie zamiast wskaźnika zwracany jest NULL.

Argumenty:
Funkcja nie przyjmuje żadnych argumentów.

Zwracana wartość:
char * - łańcuch znaków (wskaźnik do łańcucha znaków) zawierający informacje dotyczące powłok systemowych użytkowników posiadających konta w systemie.

Example:
zawartość pliku getusershell.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <unistd.h>        /* for R_OK, W_OK, X_OK, F_OK, environ, access(), lseek(), close(), read(), write(), pipe(), alarm(), sleep(), ualarm(), usleep(), pause(), chown(), chdir(), getcwd(), */
                           /* for exec[...](), nice(), getpid(), getppid(), setpgid(), setsid(), getsid(), getuid(), geteuid(), getgid(), getegid(), setuid(), seteuid(), setgid(), setegid(), fork(), */
                           /* for link(), symlink(), readlink(), unlink(), rmdir(), getlogin(), setlogin(), gethostname(), sethostname(), daemon(), chroot(), getpass(), [f]sync(), [f]truncate(), syscall(), */



int main(int argc, char **argv) {
	char *self;
#if defined(HAVE_GETUSERSHELL)
	char *usershellpath;
#endif
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<1) {
		printf("Usage: %s\n", argv[0]);
		return 0;
	}
	
#if defined(HAVE_SETUSERSHELL)
	printf("%s: setusershell(): call\n", self);
	setusershell();
	printf("%s: setusershell(): end\n", self);
#else
	/* setusershell() is not available on this OS platform !!! */
	printf("%s: setusershell() is not available on this OS platform !!!\n", self);
#endif
	
#if defined(HAVE_GETUSERSHELL)
	printf("%s: usershellpath=getusershell():\n", self);
	usershellpath=self;
	while (usershellpath!=NULL) {
		usershellpath=getusershell();
		if (usershellpath!=NULL) {
			printf("%s: usershellpath=getusershell(): usershellpath=%s\n", self, usershellpath);
		} else {
			break;
		}
	}
#else
	/* getusershell() is not available on this OS platform !!! */
	printf("%s: getusershell() is not available on this OS platform !!!\n", self);
#endif
	
#if defined(HAVE_ENDUSERSHELL)
	printf("%s: endusershell(): call\n", self);
	endusershell();
	printf("%s: endusershell(): end\n", self);
#else
	/* endusershell() is not available on this OS platform !!! */
	printf("%s: endusershell() is not available on this OS platform !!!\n", self);
#endif
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/posix/getusershell

program wyświetli stosowne informacje o sposobie działania:

getusershell: usershellpath=getusershell():
getusershell: usershellpath=getusershell(): usershellpath=/bin/sh
getusershell: usershellpath=getusershell(): usershellpath=/bin/bash
getusershell: usershellpath=getusershell(): usershellpath=/sbin/nologin
getusershell: usershellpath=getusershell(): usershellpath=(null)

#top isatty¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji isatty() znajduje się w pliku nagłówkowym unistd.h.
Deklaracja funkcji isatty() jest następująca:

/* Return 1 if FD is a valid descriptor associated
   with a terminal, zero if not.  */
extern int isatty (int __fd) __THROW;

Powiązane:
isatty(), ttyname(), ttyslot(),

Opis:

Funkcja isatty() sprawdza czy deskryptor podany w argumencie wywołania __fd jest skorelowany z terminalem i zwraca wartość 1, w przeciwnym razie zwraca wartość 0.

Argumenty:
int __fd - deskryptor sprawdzany czy jest skorelowany z terminalem.

Zwracana wartość:
int - wartość określająca czy deskryptor podany w argumencie wywołania __fd jest skorelowany z terminalem.

Example:
zawartość pliku isatty.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <unistd.h>        /* for R_OK, W_OK, X_OK, F_OK, environ, access(), lseek(), close(), read(), write(), pipe(), alarm(), sleep(), ualarm(), usleep(), pause(), chown(), chdir(), getcwd(), */
                           /* for exec[...](), nice(), getpid(), getppid(), setpgid(), setsid(), getsid(), getuid(), geteuid(). getgid(), getegid(), setuid(), seteuid(), setgid(), setegid(), fork(), */
                           /* for link(), symlink(), readlink(), unlink(), rmdir(), getlogin(), setlogin(), gethostname(), sethostname(), daemon(), chroot(), getpass(), [f]sync(), [f]truncate(), syscall(), */
#include <errno.h>         /* for errno variable, error constants, */

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
  #define WIN32_LEAN_AND_MEAN
  #include <fcntl.h>       /* for io.h, O_RDONLY, O_WRONLY, O_RDWR, O_CREAT, O_TRUNC, O_APPEND, */
  #include <io.h>          /* for open(), read(), creat(), */
#else
  #include <fcntl.h>       /* for O_RDONLY, O_WRONLY, O_RDWR, O_CREAT, O_TRUNC, O_APPEND, F_GETFL, F_SETFL, O_NONBLOCK, O_SYNC, FASYNC, O_DIRECT, O_LARGEFILE, O_DIRECTORY, O_NOFOLLOW, O_NOATIME, O_NDELAY, */
                           /* for LOCK_SH, LOCK_EX, LOCK_NB, LOCK_UN, LOCK_MAND, LOCK_READ, LOCK_WRITE, LOCK_RW, fcntl(), open(), creat(), */
#endif



int main(int argc, char **argv) {
	char *self;
	int result;
	int fprd;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage: %s </path/to/filename>\n", argv[0]);
		printf("Examples:\n");
		printf("       %s /home/local/code/ansiccode/posix/isatty\n", argv[0]);
		return 0;
	}
	
	result=isatty(0);
	if (result==1) printf("%s: result=isatty(0): result=%d descriptor is a TTY\n", self, result);
	else           printf("%s: result=isatty(0): result=%d descriptor is NOT a TTY\n", self, result);
	
	result=isatty(1);
	if (result==1) printf("%s: result=isatty(1): result=%d descriptor is a TTY\n", self, result);
	else           printf("%s: result=isatty(1): result=%d descriptor is NOT a TTY\n", self, result);
	
	result=isatty(2);
	if (result==1) printf("%s: result=isatty(2): result=%d descriptor is a TTY\n", self, result);
	else           printf("%s: result=isatty(2): result=%d descriptor is NOT a TTY\n", self, result);
	
	fprd=open(argv[1], O_RDONLY, 0644);
	if (fprd>=0) {
		printf("%s: fprd=open(argv[1]=%s, O_RDONLY=%d, 0644); fprd=%d if (fprd>=0): Successful opened file '%s'.\n", self, argv[1], O_RDONLY, fprd, argv[1]);
		
		result=isatty(fprd);
		if (result==1) printf("%s: result=isatty(fprd=%d): result=%d descriptor is a TTY\n", self, fprd, result);
		else           printf("%s: result=isatty(fprd=%d): result=%d descriptor is NOT a TTY\n", self, fprd, result);
		
		close(fprd);
	} else {
		printf("%s: fprd=open(argv[1]=%s, O_RDONLY=%d, 0644); fprd=%d if (fprd>=0): else: Unable to open file '%s', Reason: %d:%s\n", self, argv[1], O_RDONLY, fprd, argv[1], errno, strerror(errno));
	}
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/posix/isatty

program wyświetli informacje o sposobie uruchamiania programu:

Usage: /home/local/code/ansiccode/posix/isatty </path/to/filename>
Examples:
       /home/local/code/ansiccode/posix/isatty /home/local/code/ansiccode/posix/isatty

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

/home/local/code/ansiccode/posix/isatty /home/local/code/ansiccode/posix/isatty

rezultat będzie zależny od podanych argumentów wywołania programu:

isatty: result=isatty(0): result=1 descriptor is a TTY
isatty: result=isatty(1): result=1 descriptor is a TTY
isatty: result=isatty(2): result=1 descriptor is a TTY
isatty: fprd=open(argv[1]=/home/local/code/ansiccode/posix/isatty, O_RDONLY=0, 0644); fprd=3 if (fprd>=0): successful opened file '/home/local/code/ansiccode/posix/isatty'.
isatty: result=isatty(fprd=3): result=0 descriptor is NOT a TTY

#top kill¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji kill() znajduje się w pliku nagłówkowym signal.h.
Deklaracja funkcji kill() jest następująca:

/* Send signal SIG to process number PID.  If PID is zero,
   send SIG to all processes in the current process's process group.
   If PID is < -1, send SIG to all processes in process group - PID.  */
#ifdef __USE_POSIX
extern int kill (__pid_t __pid, int __sig) __THROW;
#endif /* Use POSIX.  */

Powiązane:
getpid(), getppid(), getsid(), kill(),

Opis:

Funkcja kill() wysyła do procesu __pid podanego jako pierwszy argument wywołania funkcji sygnał __sig podany w drugim argumencie wywołania funkcji.

Argumenty:
__pid_t __pid - proces do którego zostanie wysłany sygnał __sig.
int __sig - sygnał, który zostanie wysłany do procesu __pid.

Zwracana wartość:
int - W przypadku sukcesu wsyłania sygnału do procesu zwracana jest wartość 0, w przeciwnym przypadku zwracana jest wartość -1 oraz ustawiana globalna zmienna errno zawierająca powód występienia błędu.

Example:
zawartość pliku kill.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkstemp(), mkdtemp(), system(), realpath(), abs(), labs(), llabs(), getloadavg(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <unistd.h>        /* for R_OK, W_OK, X_OK, F_OK, environ, access(), lseek(), close(), read(), write(), pipe(), alarm(), sleep(), ualarm(), usleep(), pause(), chown(), chdir(), getcwd(), */
                           /* for exec[...](), nice(), getpid(), getppid(), setpgid(), setsid(), getsid(), getuid(), geteuid(), getgid(), getegid(), setuid(), seteuid(), setgid(), setegid(), fork(), */
                           /* for link(), symlink(), readlink(), unlink(), rmdir(), getlogin(), setlogin(), gethostname(), sethostname(), daemon(), chroot(), getpass(), [f]sync(), [f]truncate(), syscall(), */

#include <signal.h>        /* for SIGHUP, SIGINT, SIGQUIT, SIG_DFL, SIG_ERR, */



int main(int argc, char **argv) {
	char *self;
	pid_t pid;
	int sig;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
#else
	int result;
#endif
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage: %s <pid|0> <signal>\n", argv[0]);
		printf("Examples:\n");
		printf("       %s 0 1\n", argv[0]);
		printf("       %s 0 2\n", argv[0]);
		printf("       %s 0 3\n", argv[0]);
		return 0;
	}
	
	
	pid=atoi(argv[1]);
	printf("%s: pid=atoi(argv[1]=%s): pid=%d\n", self, argv[1], pid);
	if (pid==0) { pid=getpid(); printf("%s: if (pid==0): pid=getpid(): pid=%d\n", self, pid); }
	sig=atoi(argv[2]);
	printf("%s: sig=atoi(argv[2]=%s): pid=%d\n", self, argv[2], sig);
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	/* kill() is not available on this OS platform !!! */
	printf("%s: kill() is not available on this OS platform !!!\n", self);
#else
	printf("%s: result=kill(pid=%d, sig=%d):\n", argv[0], pid, sig);
	result=kill(pid, sig);
	printf("%s: result=kill(pid=%d, sig=%d): result=%d\n", argv[0], pid, sig, result);
#endif
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/posix/kill

program wyświetli informacje o sposobie uruchamiania programu:

Usage: /home/local/code/ansiccode/posix/kill <pid|0> <signal>
Examples:
       /home/local/code/ansiccode/posix/kill 0 1
       /home/local/code/ansiccode/posix/kill 0 2
       /home/local/code/ansiccode/posix/kill 0 3

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

/home/local/code/ansiccode/posix/kill 0 1
/home/local/code/ansiccode/posix/kill 0 2
/home/local/code/ansiccode/posix/kill 0 3

rezultat będzie zależny od podanych argumentów wywołania programu:

kill: pid=atoi(argv[1]=0): pid=0
kill: if (pid==0): pid=getpid(): pid=24135
kill: sig=atoi(argv[2]=1): pid=1
/home/local/code/ansiccode/posix/kill: result=kill(pid=24135, sig=1):
Hangup

kill: pid=atoi(argv[1]=0): pid=0
kill: if (pid==0): pid=getpid(): pid=24136
kill: sig=atoi(argv[2]=2): pid=2
/home/local/code/ansiccode/posix/kill: result=kill(pid=24136, sig=2):


kill: pid=atoi(argv[1]=0): pid=0
kill: if (pid==0): pid=getpid(): pid=24137
kill: sig=atoi(argv[2]=3): pid=3
/home/local/code/ansiccode/posix/kill: result=kill(pid=24137, sig=3):
Quit

W przypadku podania wartości "0" jako pid procesu (lub wartości, dla której funkcja atoi() zwróci wartość "0") jako pid procesu przyjmowany jest uruchomiony program, czyli program wysyła sygnał do samego siebie.

#top setegid¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji setegid() znajduje się w pliku nagłówkowym unistd.h.
Deklaracja funkcji setegid() jest następująca:

/* Set the effective group ID of the calling process to GID.  */
extern int setegid (__gid_t __gid) __THROW;

Powiązane:
getegid(), geteuid(), getgid(), getuid(), setgeid(), seteuid(), setgid(), setsid(), setuid(),

Opis:

Funkcja setegid() ustawia efektywny identyfikator grupy dla procesu wywołującego funkcję na wartość __gid podaną jako argument wywołania. W przypadku sukcesu zwracana jest wartość 0, w przeciwnym przypadku zwracana jest wartość -1 oraz ustawiana globalna zmienna errno zawierająca powód występienia błędu.

Argumenty:
__gid_t __gid - efektywny identyfikator grupy dla procesu wywołującego funkcję, który ma zostać ustawiony.

Zwracana wartość:
int - status wykonania operacji: w przypadku sukcesu zwracana jest wartość 0, w przeciwnym przypadku zwracana jest wartość -1.

#top seteuid¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji seteuid() znajduje się w pliku nagłówkowym unistd.h.
Deklaracja funkcji seteuid() jest następująca:

/* Set the effective user ID of the calling process to UID.  */
extern int seteuid (__uid_t __uid) __THROW;

Powiązane:
getegid(), geteuid(), getgid(), getuid(), setgeid(), seteuid(), setgid(), setsid(), setuid(),

Opis:

Funkcja seteuid() ustawia efektywny identyfikator użytkownika dla procesu wywołującego funkcję na wartość __uid podaną jako argument wywołania. W przypadku sukcesu zwracana jest wartość 0, w przeciwnym przypadku zwracana jest wartość -1 oraz ustawiana globalna zmienna errno zawierająca powód występienia błędu.

Argumenty:
__uid_t __uid - efektywny identyfikator użytkownika dla procesu wywołującego funkcję, który ma zostać ustawiony.

Zwracana wartość:
int - status wykonania operacji: w przypadku sukcesu zwracana jest wartość 0, w przeciwnym przypadku zwracana jest wartość -1.

#top setgid¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji setgid() znajduje się w pliku nagłówkowym unistd.h.
Deklaracja funkcji setgid() jest następująca:

/* Set the group ID of the calling process to GID.
   If the calling process is the super-user, set the real
   and effective group IDs, and the saved set-group-ID to GID;
   if not, the effective group ID is set to GID.  */
extern int setgid (__gid_t __gid) __THROW;

Powiązane:
getegid(), geteuid(), getgid(), getuid(), setegid(), seteuid(), setgid(), setsid(), setuid(),

Opis:

Funkcja setgid() ustawia rzeczywisty identyfikator grupy dla procesu wywołującego funkcję na wartość __gid podaną jako argument wywołania. W przypadku sukcesu zwracana jest wartość 0, w przeciwnym przypadku zwracana jest wartość -1 oraz ustawiana globalna zmienna errno zawierająca powód występienia błędu.

Argumenty:
__gid_t __gid - identyfikator grupy dla procesu wywołującego funkcję, który ma zostać ustawiony.

Zwracana wartość:
int - status wykonania operacji: w przypadku sukcesu zwracana jest wartość 0, w przeciwnym przypadku zwracana jest wartość -1.

#top setgrent¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji setgrent() znajduje się w pliku nagłówkowym grp.h.
Deklaracja funkcji setgrent() jest następująca:

/* Rewind the group-file stream.

   This function is a possible cancellation point and therefore not
   marked with __THROW.  */
extern void setgrent (void);

Powiązane:
endgrent(), getgrent(), getgrgid(), getgrnam(), setgrent(),

Opis:

Funkcja setgrent() jest używana do 'przewijania' do początku (jest równoważna do fseek(file, 0, 0)) "bazy danych" zawierającej informacje dotyczące grup użytkowników w systemie oraz grup do których użytkownicy należą. Informacje dotyczące grup użytkowników w systemie oraz grup do których użytkownicy należą może być przechowywana w pliku tekstowym /etc/group, w bazie Network Information Service (NIS) lub bazie Lightweight Directory Access Protocol (LDAP).

Argumenty:
Funkcja nie przyjmuje żadnych argumentów.

Zwracana wartość:
Funkcja nie zwraca żadnej wartości.

#top sethostname¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji sethostname() znajduje się w pliku nagłówkowym unistd.h.
Deklaracja funkcji sethostname() jest następująca:

#if defined __USE_BSD || (defined __USE_XOPEN && !defined __USE_UNIX98)
/* Set the name of the current host to NAME, which is LEN bytes long.
   This call is restricted to the super-user.  */
extern int sethostname (__const char *__name, size_t __len)
     __THROW __nonnull ((1)) __wur;
#endif /* Use BSD || X/Open.  */

Powiązane:
gethostname(), sethostname(),

Opis:

Funkcja sethostname()

Argumenty:
const char *__name -
size_t __len -

Zwracana wartość:
int -

Example:
zawartość pliku gethostname.c

SELECT ALL

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/posix/gethostname

program wyświetli stosowne informacje o sposobie działania:

#top setlogin¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji setlogin() znajduje się w pliku nagłówkowym unistd.h.
Deklaracja funkcji setlogin() jest następująca:

/* Set the login name returned by `getlogin'.  *:
extern int setlogin (__const char *__name) __THROW __nonnull ((1));

Powiązane:
getlogin(), getpass(), setlogin(),

Opis:

Funkcja setlogin() ustawia nazwę użytkownika bieżącej sesji na nazwę podaną w argumencie __name. Zmiana nazwy użytkownika bieżącej sesji wymaga posiadania uprawnień super-użytkownika. Funkcja jest wywoływana najczęściej w przypadku tworzenia nowej sesji dla danego użytkownika (np: w czasie logowania lub uruchamiania zdalnej powłoki). W przypadku sukcesu zmiany nazwy użytkownika zwracana jest wartość 0, w przeciwnym przypadku zwracana jest wartość -1 oraz ustawiana globalna zmienna errno zawierająca powód wystąpienia błędu.

Argumenty:
const char *__name - łańcuch znaków (wskaźnik do łańcucha znaków) zawierający nazwę użytkownika jaka ma zostać ustawiona dla bieżącej sesji.

Zwracana wartość:
int - status wykonania operacji: w przypadku sukcesu zwracana jest wartość 0, w przeciwnym przypadku zwracana jest wartość -1.

Example:
zawartość pliku setlogin.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <unistd.h>        /* for R_OK, W_OK, X_OK, F_OK, environ, access(), lseek(), close(), read(), write(), pipe(), alarm(), sleep(), ualarm(), usleep(), pause(), chown(), chdir(), getcwd(), */
                           /* for exec[...](), nice(), getpid(), getppid(), setpgid(), setsid(), getsid(), getuid(), geteuid(). getgid(), getegid(), setuid(), seteuid(), setgid(), setegid(), fork(), */
                           /* for link(), symlink(), readlink(), unlink(), rmdir(), getlogin(), setlogin(), gethostname(), sethostname(), daemon(), chroot(), getpass(), [f]sync(), [f]truncate(), syscall(), */
#include <errno.h>         /* for errno constant, error constants, */



int main(int argc, char **argv) {
	char *self;
#if defined(HAVE_SETLOGIN)
	int result;
#endif
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage: %s <login>\n", argv[0]);
		printf("Examples:\n", argv[0]);
		printf("       %s <login>\n", argv[0]);
		return 0;
	}
	
#if defined(HAVE_SETLOGIN)
	result=setlogin(argv[1]);
	if (result>=0) printf("%s: result=setlogin(argv[1]=%s): result=%d if (result>=0): Successful setlogin().\n", self, argv[1], result);
	else           printf("%s: result=setlogin(argv[1]=%s): result=%d if (result>=0): else: Unable to setlogin(), Reason: %d:%s\n", self, argv[1], result, errno, strerror(errno));
#else
	/* setlogin() is not available on this OS platform !!! */
	printf("%s: setlogin() is not available on this OS platform !!!\n", self);
#endif
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/posix/setlogin

program wyświetli informacje o sposobie uruchamiania programu:

Usage: /home/local/code/ansiccode/posix/setlogin <login>
Examples:
       /home/local/code/ansiccode/posix/setlogin user

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

/home/local/code/ansiccode/posix/setlogin user

rezultat będzie zależny od podanych argumentów wywołania programu:

setlogin: result=setlogin(argv[1]=user): result=-1 if (result>=0): else: Unable to set login, Reason: 38:Function not implemented

#top setpgid¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji setpgid() znajduje się w pliku nagłówkowym unistd.h.
Deklaracja funkcji setpgid() jest następująca:

/* Set the process group ID of the process matching PID to PGID.
   If PID is zero, the current process's process group ID is set.
   If PGID is zero, the process ID of the process is used.  */
extern int setpgid (__pid_t __pid, __pid_t __pgid) __THROW;

Powiązane:
getpgid(), getpgrp(), setpgid(), setpgrp(),

Opis:

Funkcja setpgid()

Argumenty:
__pid_t __pid -
__pid_t __pgid -

Zwracana wartość:
int -

#top setpgrp¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji setpgrp() znajduje się w pliku nagłówkowym unistd.h.
Deklaracja funkcji setpgrp() jest następująca:

/* Set the process group ID of the calling process to its own PID.
   This is exactly the same as `setpgid (0, 0)'.  */
extern int setpgrp (void) __THROW;

Powiązane:
getpgid(), getpgrp(), setpgid(), setpgrp(),

Opis:

Funkcja setpgrp()

Argumenty:
Funkcja nie przyjmuje żadnych argumentów.

Zwracana wartość:
int -

#top setpwent¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji setpwent() znajduje się w pliku nagłówkowym pwd.h.
Deklaracja funkcji setpwent() jest następująca:

/* Rewind the password-file stream.

   This function is a possible cancellation point and therefore not
   marked with __THROW.  */
extern void setpwent (void);

Powiązane:
endpwent(), getpwent(), getpwnam(), getpwuid(), setpwent(),

Opis:

Funkcja setpwent() jest używana do 'przewijania' do początku (jest równoważna do fseek(file, 0, 0)) "bazy danych" zawierającej informacje dotyczące użytkowników w systemie. Informacje dotyczące użytkowników w systemie może być przechowywana w pliku tekstowym /etc/passwd, w bazie Network Information Service (NIS) lub w bazie Lightweight Directory Access Protocol (LDAP).

Argumenty:
Funkcja nie przyjmuje żadnych argumentów.

Zwracana wartość:
Funkcja nie zwraca żadnej wartości.

#top setsid¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji setsid() znajduje się w pliku nagłówkowym unistd.h.
Deklaracja funkcji setsid() jest następująca:

/* Create a new session with the calling process as its leader.
   The process group IDs of the session and the calling process
   are set to the process ID of the calling process, which is returned.  */
extern __pid_t setsid (void) __THROW;

Powiązane:
getegid(), geteuid(), getgid(), getuid(), setgeid(), seteuid(), setgid(), setsid(), setuid(),

Opis:

Funkcja setsid()

Argumenty:
Funkcja nie przyjmuje żadnych argumentów.

Zwracana wartość:
__pid_t -

#top setuid¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji setuid() znajduje się w pliku nagłówkowym unistd.h.
Deklaracja funkcji setuid() jest następująca:

/* Set the user ID of the calling process to UID.
   If the calling process is the super-user, set the real
   and effective user IDs, and the saved set-user-ID to UID;
   if not, the effective user ID is set to UID.  */
extern int setuid (__uid_t __uid) __THROW;

Powiązane:
getegid(), geteuid(), getgid(), getuid(), setgeid(), seteuid(), setgid(), setsid(), setuid(),

Opis:

Funkcja setuid() ustawia rzeczywisty identyfikator użytkownika dla procesu wywołującego funkcję na wartość __uid podaną jako argument wywołania. W przypadku sukcesu zwracana jest wartość 0, w przeciwnym przypadku zwracana jest wartość -1 oraz ustawiana globalna zmienna errno zawierająca powód występienia błędu.

Argumenty:
__uid_t __uid - identyfikator użytkownika dla procesu wywołującego funkcję, który ma zostać ustawiony.

Zwracana wartość:
int - status wykonania operacji: w przypadku sukcesu zwracana jest wartość 0, w przeciwnym przypadku zwracana jest wartość -1.

Example:
zawartość pliku setuid.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <stdlib.h>        /* for RAND_MAX, EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, atoi(), atol(), atoll(), atof(), strtod(), strtof(), strtold(), strtol(), strtoul(), strtoq(), strtouq(), strtoll(), strtoull(), */
                           /* for sys/types.h, malloc.h replaced by stdlib.h, random(), srandom(), rand(), srand(), abort(), atexit(), on_exit(), exit(), getenv(), */
                           /* for putenv(), setenv(), clearenv(), mktemp(), mkstemp(), mkdtemp(), system(), realpath(), abs(), labs(), llabs(), getloadavg(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <unistd.h>        /* for R_OK, W_OK, X_OK, F_OK, environ, access(), lseek(), close(), read(), write(), pipe(), alarm(), sleep(), ualarm(), usleep(), pause(), chown(), chdir(), getcwd(), */
                           /* for exec[...](), nice(), getpid(), getppid(), setpgid(), setsid(), getsid(), getuid(), geteuid(). getgid(), getegid(), setuid(), seteuid(), setgid(), setegid(), fork(), */
                           /* for link(), symlink(), readlink(), unlink(), rmdir(), getlogin(), setlogin(), gethostname(), sethostname(), daemon(), chroot(), getpass(), [f]sync(), [f]truncate(), syscall(), */
#include <errno.h>         /* for errno constant, error constants, */



int main(int argc, char **argv) {
	char *self;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
#else
	uid_t uid;
	gid_t gid;
	pid_t pid;
	int result;
#endif
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<3) {
		printf("Usage: %s <uid> <gid>\n", argv[0]);
		printf("Examples:\n");
		printf("Usage: %s 501 100\n", argv[0]);
		printf("Usage: %s 501 48\n", argv[0]);
		printf("Usage: %s 501 95\n", argv[0]);
		printf("Usage: %s 0 100\n", argv[0]);
		printf("Usage: %s 501 100\n", argv[0]);
		return 0;
	}
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	/* setuid() is not available on this OS platform !!! */
	printf("%s: setuid() is not available on this OS platform !!!\n", self);
	
	/* seteuid() is not available on this OS platform !!! */
	printf("%s: seteuid() is not available on this OS platform !!!\n", self);
	
	/* setgid() is not available on this OS platform !!! */
	printf("%s: setgid() is not available on this OS platform !!!\n", self);
	
	/* setegid() is not available on this OS platform !!! */
	printf("%s: setegid() is not available on this OS platform !!!\n", self);
	
	/* setsid() is not available on this OS platform !!! */
	printf("%s: setsid() is not available on this OS platform !!!\n", self);
#else
	uid=atoi(argv[1]);
	gid=atoi(argv[2]);
	
	result=setuid(uid);
	if (result>=0) printf("%s: result=setuid(uid=%d): result=%d if (result>=0): Successful setuid().\n", self, (int)uid, result);
	else           printf("%s: result=setuid(uid=%d): result=%d if (result>=0): else: Unable to setuid(), Reason: %d:%s\n", self, (int)uid, result, errno, strerror(errno));
	
	result=seteuid(uid);
	if (result>=0) printf("%s: result=seteuid(uid=%d): result=%d if (result>=0): Successful seteuid().\n", self, (int)uid, result);
	else           printf("%s: result=seteuid(uid=%d): result=%d if (result>=0): else: Unable to seteuid(), Reason: %d:%s\n", self, (int)uid, result, errno, strerror(errno));
	
	result=setgid(gid);
	if (result>=0) printf("%s: result=setgid(gid=%d): result=%d if (result>=0): Successful setgid().\n", self, (int)gid, result);
	else           printf("%s: result=setgid(gid=%d): result=%d if (result>=0): else: Unable to setgid(), Reason: %d:%s\n", self, (int)gid, result, errno, strerror(errno));
	
	result=setegid(gid);
	if (result>=0) printf("%s: result=setegid(gid=%d): result=%d if (result>=0): Successful setegid().\n", self, (int)gid, result);
	else           printf("%s: result=setegid(gid=%d): result=%d if (result>=0): else: Unable to setegid(), Reason: %d:%s\n", self, (int)gid, result, errno, strerror(errno));
	
	pid=setsid();
	printf("%s: pid=setsid(): pid=%d\n", self, (int)pid);
#endif
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/posix/setuid

program wyświetli informacje o sposobie uruchamiania programu:

Usage: /home/local/code/ansiccode/posix/setuid <uid> <gid>
Examples:
       /home/local/code/ansiccode/posix/setuid 501 100
       /home/local/code/ansiccode/posix/setuid 501 48
       /home/local/code/ansiccode/posix/setuid 501 95
       /home/local/code/ansiccode/posix/setuid 0 100
       /home/local/code/ansiccode/posix/setuid 501 100

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

/home/local/code/ansiccode/posix/setuid 501 100
/home/local/code/ansiccode/posix/setuid 501 48
/home/local/code/ansiccode/posix/setuid 501 95
/home/local/code/ansiccode/posix/setuid 0 100
/home/local/code/ansiccode/posix/setuid 501 100

rezultat będzie zależny od podanych argumentów wywołania programu:

setuid: result=setuid(uid=501): result=0 if (result>=0): Successful setuid().
setuid: result=seteuid(uid=501): result=0 if (result>=0): Successful seteuid().
setuid: result=setgid(gid=100): result=0 if (result>=0): Successful setgid().
setuid: result=setegid(gid=100): result=0 if (result>=0): Successful setegid().
setuid: pid=setsid(): pid=-1

setuid: result=setuid(uid=501): result=0 if (result>=0): Successful setuid().
setuid: result=seteuid(uid=501): result=0 if (result>=0): Successful seteuid().
setuid: result=setgid(gid=48): result=-1 if (result>=0): else: Unable to setgid(), Reason: 1:Operation not permitted
setuid: result=setegid(gid=48): result=-1 if (result>=0): else: Unable to setegid(), Reason: 1:Operation not permitted
setuid: pid=setsid(): pid=-1

setuid: result=setuid(uid=501): result=0 if (result>=0): Successful setuid().
setuid: result=seteuid(uid=501): result=0 if (result>=0): Successful seteuid().
setuid: result=setgid(gid=95): result=-1 if (result>=0): else: Unable to setgid(), Reason: 1:Operation not permitted
setuid: result=setegid(gid=95): result=-1 if (result>=0): else: Unable to setegid(), Reason: 1:Operation not permitted
setuid: pid=setsid(): pid=-1

setuid: result=setuid(uid=0): result=-1 if (result>=0): else: Unable to setuid(), Reason: 1:Operation not permitted
setuid: result=seteuid(uid=0): result=-1 if (result>=0): else: Unable to seteuid(), Reason: 1:Operation not permitted
setuid: result=setgid(gid=100): result=0 if (result>=0): Successful setgid().
setuid: result=setegid(gid=100): result=0 if (result>=0): Successful setegid().
setuid: pid=setsid(): pid=-1

setuid: result=setuid(uid=501): result=0 if (result>=0): Successful setuid().
setuid: result=seteuid(uid=501): result=0 if (result>=0): Successful seteuid().
setuid: result=setgid(gid=100): result=0 if (result>=0): Successful setgid().
setuid: result=setegid(gid=100): result=0 if (result>=0): Successful setegid().
setuid: pid=setsid(): pid=-1

#top setusershell¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji setusershell() znajduje się w pliku nagłówkowym unistd.h.
Deklaracja funkcji setusershell() jest następująca:

/* Successive calls return the shells listed in `/etc/shells'.  */
extern void setusershell (void) __THROW; /* Rewind and re-read the file.  */

Powiązane:
endusershell(), getusershell(), setusershell(),

Opis:

Funkcja setusershell() jest używana do 'przewijania' do początku (jest równoważna do fseek(file, 0, 0)) "bazy danych" zawierającej informacje dotyczące powłok systemowych użytkowników posiadających konta w systemie. Informacje dotyczące powłok systemowych użytkowników posiadających konta w systemie przechowywane są w pliku tekstowym /etc/shells.

Argumenty:
Funkcja nie przyjmuje żadnych argumentów.

Zwracana wartość:
Funkcja nie zwraca żadnej wartości.

Example:
zawartość pliku setusershell.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <unistd.h>        /* for R_OK, W_OK, X_OK, F_OK, environ, access(), lseek(), close(), read(), write(), pipe(), alarm(), sleep(), ualarm(), usleep(), pause(), chown(), chdir(), getcwd(), */
                           /* for exec[...](), nice(), getpid(), getppid(), setpgid(), setsid(), getsid(), getuid(), geteuid(). getgid(), getegid(), setuid(), seteuid(), setgid(), setegid(), fork(), */
                           /* for link(), symlink(), readlink(), unlink(), rmdir(), getlogin(), setlogin(), gethostname(), sethostname(), daemon(), chroot(), getpass(), [f]sync(), [f]truncate(), syscall(), */



int main(int argc, char **argv) {
	char *self;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<1) {
		printf("Usage: %s\n", argv[0]);
		return 0;
	}
	
#if defined(HAVE_SETUSERSHELL)
	printf("%s: setusershell(): call\n", self);
	setusershell();
	printf("%s: setusershell(): end\n", self);
#else
	/* setusershell() is not available on this OS platform !!! */
	printf("%s: setusershell() is not available on this OS platform !!!\n", self);
#endif
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/posix/setusershell

program wyświetli stosowne informacje o sposobie działania:

setusershell: setusershell(): call
setusershell: setusershell(): end

#top ttyname¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji ttyname() znajduje się w pliku nagłówkowym unistd.h.
Deklaracja funkcji ttyname() jest następująca:

/* Return the pathname of the terminal FD is open on, or NULL on errors.
   The returned storage is good only until the next call to this function.  */
extern char *ttyname (int __fd) __THROW;

Powiązane:
isatty(), ttyname(), ttyslot(),

Opis:

Funkcja ttyname() zwraca łańcuch znaków (wskaźnik do łańcucha znaków) zawierający informację dotyczącą ścieżki do terminala określonego deskryptorem __fd przekazanym jako argument wywołania funkcji. Dla deskryptora wskazującego na prawidłowy terminal zwracany jest wskaźnik zawierający ścieżkę do terminala, w przeciwym przypadku zwrcanany wskaźnik jest NULL.

Argumenty:
int - deskryptor do terminala, dla którego zostanie zwrócona ścieżka.

Zwracana wartość:
char * - łańcuch znaków (wskaźnik do łańcucha znaków) zawierający informację dotyczącą ścieżki do terminala określonego deskryptorem __fd.

Example:
zawartość pliku ttyname.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <unistd.h>        /* for R_OK, W_OK, X_OK, F_OK, environ, access(), lseek(), close(), read(), write(), pipe(), alarm(), sleep(), ualarm(), usleep(), pause(), chown(), chdir(), getcwd(), */
                           /* for exec[...](), nice(), getpid(), getppid(), setpgid(), setsid(), getsid(), getuid(), geteuid(), getgid(), getegid(), setuid(), seteuid(), setgid(), setegid(), fork(), */
                           /* for link(), symlink(), readlink(), unlink(), rmdir(), getlogin(), setlogin(), gethostname(), sethostname(), daemon(), chroot(), getpass(), [f]sync(), [f]truncate(), syscall(), */
#include <errno.h>         /* for errno variable, error constants, */

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
  #define WIN32_LEAN_AND_MEAN
  #include <fcntl.h>       /* for io.h, O_RDONLY, O_WRONLY, O_RDWR, O_CREAT, O_TRUNC, O_APPEND, */
#else
  #include <fcntl.h>       /* for O_RDONLY, O_WRONLY, O_RDWR, O_CREAT, O_TRUNC, O_APPEND, F_GETFL, F_SETFL, O_NONBLOCK, O_SYNC, FASYNC, O_DIRECT, O_LARGEFILE, O_DIRECTORY, O_NOFOLLOW, O_NOATIME, O_NDELAY, */
                           /* for LOCK_SH, LOCK_EX, LOCK_NB, LOCK_UN, LOCK_MAND, LOCK_READ, LOCK_WRITE, LOCK_RW, fcntl(), open(), creat(), */
#endif



int main(int argc, char **argv) {
	char *self;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
#else
	char *ttyinfo;
	int fprd;
#endif
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage: %s </path/to/filename>\n", argv[0]);
		printf("Examples:\n");
		printf("       %s /dev/tty\n", argv[0]);
		printf("       %s /home/local/code/ansiccode/posix/ttyname\n", argv[0]);
		return 0;
	}
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	/* ttyname() is not available on this OS platform !!! */
	printf("%s: ttyname() is not available on this OS platform !!!\n", self);
#else
	ttyinfo=ttyname(STDIN_FILENO);
	printf("%s: ttyinfo=ttyname(STDIN_FILENO=%d): ttyinfo(%p)=%s\n", self, STDIN_FILENO, (void*)ttyinfo, ttyinfo);
	
	ttyinfo=ttyname(STDOUT_FILENO);
	printf("%s: ttyinfo=ttyname(STDOUT_FILENO=%d): ttyinfo(%p)=%s\n", self, STDOUT_FILENO, (void*)ttyinfo, ttyinfo);
	
	ttyinfo=ttyname(STDERR_FILENO);
	printf("%s: ttyinfo=ttyname(STDERR_FILENO=%d): ttyinfo(%p)=%s\n", self, STDERR_FILENO, (void*)ttyinfo, ttyinfo);
	
	fprd=open(argv[1], O_RDONLY, 0644);
	if (fprd>=0) {
		printf("%s: fprd=open(argv[1]=%s, O_RDONLY=%d, 0644); fprd=%d if (fprd>=0): Successful opened file '%s'.\n", self, argv[1], O_RDONLY, fprd, argv[1]);
		
		ttyinfo=ttyname(fprd);
		printf("%s: ttyinfo=ttyname(fprd=%d): ttyinfo(%p)=%s\n", self, fprd, (void*)ttyinfo, ttyinfo);
		
		close(fprd);
	} else {
		printf("%s: fprd=open(argv[1]=%s, O_RDONLY=%d, 0644); fprd=%d if (fprd>=0): else: Unable to open file '%s', Reason: %d:%s\n", self, argv[1], O_RDONLY, fprd, argv[1], errno, strerror(errno));
	}
#endif
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/posix/ttyname

program wyświetli informacje o sposobie uruchamiania programu:

Usage: /home/local/code/ansiccode/posix/ttyname </path/to/filename>
Examples:
       /home/local/code/ansiccode/posix/ttyname /dev/tty
       /home/local/code/ansiccode/posix/ttyname /home/local/code/ansiccode/posix/ttyname

jako argument wywołania programu można podać analogiczne jak poniżej argumenty:

/home/local/code/ansiccode/posix/ttyname /dev/tty
/home/local/code/ansiccode/posix/ttyname /home/local/code/ansiccode/posix/ttyname

rezultat będzie zależny od podanych argumentów wywołania programu:

ttyname: ttyinfo=ttyname(STDIN_FILENO=0): ttyinfo(0x8052008)=/dev/pts/66
ttyname: ttyinfo=ttyname(STDOUT_FILENO=1): ttyinfo(0x8052008)=/dev/pts/66
ttyname: ttyinfo=ttyname(STDERR_FILENO=2): ttyinfo(0x8052008)=/dev/pts/66
ttyname: fprd=open(argv[1]=/dev/tty, O_RDONLY=0, 0644); fprd=3 if (fprd>=0): Successful opened file '/dev/tty'.
ttyname: ttyinfo=ttyname(fprd=3): ttyinfo(0x8052008)=/dev/tty

ttyname: ttyinfo=ttyname(STDIN_FILENO=0): ttyinfo(0x87a1008)=/dev/pts/66
ttyname: ttyinfo=ttyname(STDOUT_FILENO=1): ttyinfo(0x87a1008)=/dev/pts/66
ttyname: ttyinfo=ttyname(STDERR_FILENO=2): ttyinfo(0x87a1008)=/dev/pts/66
ttyname: fprd=open(argv[1]=/home/local/code/ansiccode/posix/ttyname, O_RDONLY=0, 0644); fprd=3 if (fprd>=0): Successful opened file '/home/local/code/ansiccode/posix/ttyname'.
ttyname: ttyinfo=ttyname(fprd=3): ttyinfo((nil))=(null)

Na powyższym przykładzie doskonale widać również: The returned storage is good only until the next call to this function., że zwracany jest zawsze ten sam wskaźnik do bufora zawierającego informacje dotyczące ścieżki do terminala oraz, że ten wskaźnik zawiera prawidłowe informacje do czasu kolejnego wywołania funkcji ttyname().

#top ttyslot¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji ttyslot() znajduje się w pliku nagłówkowym unistd.h.
Deklaracja funkcji ttyslot() jest następująca:

/* Return the index into the active-logins file (utmp) for
   the controlling terminal.  */
extern int ttyslot (void) __THROW;

Powiązane:
isatty(), ttyname(), ttyslot(),

Opis:

Funkcja ttyslot()

Argumenty:
Funkcja nie przyjmuje żadnych argumentów.

Zwracana wartość:
int -

Example:
zawartość pliku ttyslot.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */
#include <unistd.h>        /* for R_OK, W_OK, X_OK, F_OK, environ, access(), lseek(), close(), read(), write(), pipe(), alarm(), sleep(), ualarm(), usleep(), pause(), chown(), chdir(), getcwd(), */
                           /* for exec[...](), nice(), getpid(), getppid(), setpgid(), setsid(), getsid(), getuid(), geteuid(). getgid(), getegid(), setuid(), seteuid(), setgid(), setegid(), fork(), */
                           /* for link(), symlink(), readlink(), unlink(), rmdir(), getlogin(), setlogin(), gethostname(), sethostname(), daemon(), chroot(), getpass(), [f]sync(), [f]truncate(), syscall(), */



int main(int argc, char **argv) {
	char *self;
#if defined(HAVE_TTYSLOT)
	int ttyfd;
#endif
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<1) {
		printf("Usage: %s\n", argv[0]);
		return 0;
	}
	
#if defined(HAVE_TTYSLOT)
	ttyfd=ttyslot();
	printf("%s: ttyfd=ttyslot(): ttyfd=%d\n", self, ttyfd);
#else
	/* ttyslot() is not available on this OS platform !!! */
	printf("%s: ttyslot() is not available on this OS platform !!!\n", self);
#endif
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/posix/ttyslot

program wyświetli stosowne informacje o sposobie działania:

ttyslot: ttyfd=ttyslot(): ttyfd=0

#top uname¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | www.opennet.ru

Deklaracja funkcji uname() znajduje się w pliku nagłówkowym sys/utsname.h.
Deklaracja funkcji uname() jest następująca:

/* Put information about the system in NAME.  */
extern int uname (struct utsname *__name) __THROW;

Powiązane:

Opis:

Funkcja uname() zwraca informacje dotyczące uruchomionego systemu operacyjnego we wskaźniku do struktury przekazanym w argumencie __name. W przypadku sukcesu zwracana jest wartość 0, w przeciwnym przypadku zwracana jest wartość -1 oraz ustawiana globalna zmienna errno zawierająca powód występienia błędu. W przypadku, gdy przekazany jako argument wskaźnik jest NULL to kod występienia błędu zostanie ustawiony na EINVAL.

Argumenty:
struct utsname *__name - wskaźnik do struktury w którym funkcja ustawia informacje dotyczące uruchomionego systemu operacyjnego.

Zwracana wartość:
int - status wykonania operacji: w przypadku sukcesu zwracana jest wartość 0, w przeciwnym przypadku zwracana jest wartość -1.

Example:
zawartość pliku uname.c

SELECT ALL

#define  _GNU_SOURCE  1    /* for environ defined in unistd.h, to avoid warning implicit declaration of function basename, which defined in string.h */
#include <stdio.h>         /* for FILE, va_list, EOF, SEEK_SET, SEEK_CUR, SEEK_END, stdin, stdout, stderr, remove(), rename(), tmpfile(), tmpnam(), tempnam(), fclose(), */
                           /* fflush(), fopen(), freopen(), fprintf(), printf(), snprintf(), scanf(), sscanf(), fgetc(), getc(), getchar(), fputc(), putc(), putchar(), */
                           /* fgets(), gets(), fputs(), puts(), fread(), fwrite(), fseek(), ftell(), rewind(), feof(), ferror(), fileno(), popen(), pclose(), */
#include <string.h>        /* for memcpy(), memmove(), memset(), memcmp(), memchr(), memrchr(), str[n]cpy(), str[n]cat(), str[n]cmp(), strcoll(), str[n]dup(), strchr(), strrchr(), strstr(), */
                           /* strtok(), strcasestr(), memmem(), mempcpy(), str[n]len(), strerror(), bcopy(), bzero(), strcasecmp(), strsep(), basename(), */

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
  #define WIN32_LEAN_AND_MEAN
  #include <windows.h>     /* for windef.h, wincon.h, winbase.h, winuser.h, winver.h, winsock.h, */
#else
  #include <sys/utsname.h> /* for struct utsname, uname(), */
#endif



int main(int argc, char **argv) {
	char *self;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
#else
	struct utsname suname;
	int result;
#endif
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<1) {
		printf("Usage: %s\n", argv[0]);
		return 0;
	}
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	/* uname() is not available on this OS platform !!! */
	printf("%s: uname() is not available on this OS platform !!!\n", self);
#else
	printf("%s: result=uname(&suname):\n", self);
	result=uname(&suname);
	printf("%s: result=uname(&suname): result=%d\n", self, result);
	
	printf("%s: suname.sysname=%s\n", self, suname.sysname);
	printf("%s: suname.nodename=%s\n", self, suname.nodename);
	printf("%s: suname.release=%s\n", self, suname.release);
	printf("%s: suname.version=%s\n", self, suname.version);
	printf("%s: suname.machine=%s\n", self, suname.machine);
	printf("%s: suname.domainname=%s\n", self, suname.domainname);
#endif
	
	return 0;
}

program należy skompilować komendą make (jako argument należy podać plik Makefile zależny od systemu operacyjnego, domyślnie make próbuje użyć pliku Makefile):

make clean all # system Linux
make -f Makefile clean all # system Linux
make -f Makefile.obsd clean all # system OpenBSD
make -f Makefile.fbsd clean all # system FreeBSD
make -f Makefile.sol clean all # system Solaris
make -f Makefile.beos clean all # system BeOS
make -f Makefile.win clean all # system Windows

a następnie uruchomić bez argumentów:

/home/local/code/ansiccode/posix/uname

program wyświetli stosowne informacje o sposobie działania:

uname: result=uname(&suname):
uname: result=uname(&suname): result=0
uname: suname.sysname=Linux
uname: suname.nodename=*****
uname: suname.release=2.6.18-128.el5
uname: suname.version=#1 SMP Wed Jan 21 10:44:23 EST 2009
uname: suname.machine=i686
uname: suname.domainname=(none)

Zmodyfikowany ostatnio: 2015/10/01 19:46:12 (8 lat temu), textsize: 221 kB, htmlsize: 320 kB

Zapraszam do komentowania, zgłaszania sugestii, propozycji, własnych przykładów, ...

Dodaj komentarzKomentarze użytkowników