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

CONTENT

CHANGES

Szukaj

#top Sockets¶

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

code / ansic / Sockets

#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 związanych z na zmiennych.

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: $(ACCEPT_TCP) ..., 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 accept-tcp należy zakomentować ostatnią pozycję rozpoczynającą się od make: $(ACCEPT_TCP) ... (wstawić na początku przed make znak #), a następnie odkomentować pozycję: #make: $(ACCEPT_TCP) (usunąć znak #).

#top Makefile (linux)¶

SELECT ALL

# Project: Project
# Makefile created

GCC         = gcc
INCS        = -DHAVE_STRUCT_IPHDR=1 -DHAVE_SOCKATMARK=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        = -lm
LIBDIRS     =
LDFLAGS     = $(LIBDIRS) $(LIBS)
RM          = rm -f
MKDCMD      = mkdir -p

ACCEPT_TCP  = accept-tcp
ACCEPT_UNIX = accept-unix
BIND        = bind
CONNECT_TCP = connect-tcp
CONNECT_UNIX= connect-unix
GETPEERNAME = getpeername
GETSOCKNAME = getsockname
GETSOCKOPT  = getsockopt
INADDR_ANY  = INADDR_ANY
INADDR_NONE = INADDR_NONE
IPPROTO_ICMP= IPPROTO_ICMP
IPPROTO_RAW_RECV= IPPROTO_RAW-recv
IPPROTO_RAW_SEND= IPPROTO_RAW-send
LISTEN      = listen
RECV        = recv
RECVFROM    = recvfrom
RECVMSG     = recvmsg
SELECT      = select
SEND        = send
SENDMSG     = sendmsg
SENDTO      = sendto
SETSOCKOPT  = setsockopt
SHUTDOWN    = shutdown
SOCKATMARK  = sockatmark
SOCKET      = socket
SOCKETPAIR  = socketpair



all: objdir make

objdir:
	$(MKDCMD) obj/

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

#make: $(ACCEPT_TCP)
#make: $(ACCEPT_UNIX)
#make: $(BIND)
#make: $(CONNECT_TCP)
#make: $(CONNECT_UNIX)
#make: $(GETPEERNAME)
#make: $(GETSOCKNAME)
#make: $(GETSOCKOPT)
#make: $(INADDR_ANY)
#make: $(INADDR_NONE)
#make: $(IPPROTO_ICMP)
#make: $(IPPROTO_RAW_RECV)
#make: $(IPPROTO_RAW_SEND)
#make: $(LISTEN)
#make: $(RECV)
#make: $(RECVFROM)
#make: $(RECVMSG)
#make: $(SELECT)
#make: $(SEND)
#make: $(SENDMSG)
#make: $(SENDTO)
#make: $(SETSOCKOPT)
#make: $(SHUTDOWN)
#make: $(SOCKATMARK)
#make: $(SOCKET)
#make: $(SOCKETPAIR)
make: $(ACCEPT_TCP) $(ACCEPT_UNIX) $(BIND) $(CONNECT_TCP) $(CONNECT_UNIX) $(GETPEERNAME) $(GETSOCKNAME) $(GETSOCKOPT) $(INADDR_ANY) $(INADDR_NONE) $(IPPROTO_ICMP) $(IPPROTO_RAW_RECV) $(IPPROTO_RAW_SEND) $(LISTEN) $(RECV) $(RECVFROM) $(RECVMSG) $(SELECT) $(SEND) $(SENDMSG) $(SENDTO) $(SETSOCKOPT) $(SHUTDOWN) $(SOCKATMARK) $(SOCKET) $(SOCKETPAIR)



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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#top Makefile.obsd¶

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        =
LIBDIRS     =
LDFLAGS     = $(LIBDIRS) $(LIBS)
RM          = rm -f
MKDCMD      = mkdir -p

ACCEPT_TCP  = accept-tcp
ACCEPT_UNIX = accept-unix
BIND        = bind
CONNECT_TCP = connect-tcp
CONNECT_UNIX= connect-unix
GETPEERNAME = getpeername
GETSOCKNAME = getsockname
GETSOCKOPT  = getsockopt
INADDR_ANY  = INADDR_ANY
INADDR_NONE = INADDR_NONE
IPPROTO_ICMP= IPPROTO_ICMP
IPPROTO_RAW_RECV= IPPROTO_RAW-recv
IPPROTO_RAW_SEND= IPPROTO_RAW-send
LISTEN      = listen
RECV        = recv
RECVFROM    = recvfrom
RECVMSG     = recvmsg
SELECT      = select
SEND        = send
SENDMSG     = sendmsg
SENDTO      = sendto
SETSOCKOPT  = setsockopt
SHUTDOWN    = shutdown
SOCKATMARK  = sockatmark
SOCKET      = socket
SOCKETPAIR  = socketpair



all: objdir make

objdir:
	$(MKDCMD) obj/

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

#make: $(ACCEPT_TCP)
#make: $(ACCEPT_UNIX)
#make: $(BIND)
#make: $(CONNECT_TCP)
#make: $(CONNECT_UNIX)
#make: $(GETPEERNAME)
#make: $(GETSOCKNAME)
#make: $(GETSOCKOPT)
#make: $(INADDR_ANY)
#make: $(INADDR_NONE)
#make: $(IPPROTO_ICMP)
#make: $(IPPROTO_RAW_RECV)
#make: $(IPPROTO_RAW_SEND)
#make: $(LISTEN)
#make: $(RECV)
#make: $(RECVFROM)
#make: $(RECVMSG)
#make: $(SELECT)
#make: $(SEND)
#make: $(SENDMSG)
#make: $(SENDTO)
#make: $(SETSOCKOPT)
#make: $(SHUTDOWN)
#make: $(SOCKATMARK)
#make: $(SOCKET)
#make: $(SOCKETPAIR)
make: $(ACCEPT_TCP) $(ACCEPT_UNIX) $(BIND) $(CONNECT_TCP) $(CONNECT_UNIX) $(GETPEERNAME) $(GETSOCKNAME) $(GETSOCKOPT) $(INADDR_ANY) $(INADDR_NONE) $(IPPROTO_ICMP) $(IPPROTO_RAW_RECV) $(IPPROTO_RAW_SEND) $(LISTEN) $(RECV) $(RECVFROM) $(RECVMSG) $(SELECT) $(SEND) $(SENDMSG) $(SENDTO) $(SETSOCKOPT) $(SHUTDOWN) $(SOCKATMARK) $(SOCKET) $(SOCKETPAIR)



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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#top Makefile.fbsd¶

SELECT ALL

# Project: Project
# Makefile created

GCC         = gcc
INCS        = -DHAVE_SOCKATMARK=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
MKDCMD      = mkdir -p

ACCEPT_TCP  = accept-tcp
ACCEPT_UNIX = accept-unix
BIND        = bind
CONNECT_TCP = connect-tcp
CONNECT_UNIX= connect-unix
GETPEERNAME = getpeername
GETSOCKNAME = getsockname
GETSOCKOPT  = getsockopt
INADDR_ANY  = INADDR_ANY
INADDR_NONE = INADDR_NONE
IPPROTO_ICMP= IPPROTO_ICMP
IPPROTO_RAW_RECV= IPPROTO_RAW-recv
IPPROTO_RAW_SEND= IPPROTO_RAW-send
LISTEN      = listen
RECV        = recv
RECVFROM    = recvfrom
RECVMSG     = recvmsg
SELECT      = select
SEND        = send
SENDMSG     = sendmsg
SENDTO      = sendto
SETSOCKOPT  = setsockopt
SHUTDOWN    = shutdown
SOCKATMARK  = sockatmark
SOCKET      = socket
SOCKETPAIR  = socketpair



all: objdir make

objdir:
	$(MKDCMD) obj/

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

#make: $(ACCEPT_TCP)
#make: $(ACCEPT_UNIX)
#make: $(BIND)
#make: $(CONNECT_TCP)
#make: $(CONNECT_UNIX)
#make: $(GETPEERNAME)
#make: $(GETSOCKNAME)
#make: $(GETSOCKOPT)
#make: $(INADDR_ANY)
#make: $(INADDR_NONE)
#make: $(IPPROTO_ICMP)
#make: $(IPPROTO_RAW_RECV)
#make: $(IPPROTO_RAW_SEND)
#make: $(LISTEN)
#make: $(RECV)
#make: $(RECVFROM)
#make: $(RECVMSG)
#make: $(SELECT)
#make: $(SEND)
#make: $(SENDMSG)
#make: $(SENDTO)
#make: $(SETSOCKOPT)
#make: $(SHUTDOWN)
#make: $(SOCKATMARK)
#make: $(SOCKET)
#make: $(SOCKETPAIR)
make: $(ACCEPT_TCP) $(ACCEPT_UNIX) $(BIND) $(CONNECT_TCP) $(CONNECT_UNIX) $(GETPEERNAME) $(GETSOCKNAME) $(GETSOCKOPT) $(INADDR_ANY) $(INADDR_NONE) $(IPPROTO_ICMP) $(IPPROTO_RAW_RECV) $(IPPROTO_RAW_SEND) $(LISTEN) $(RECV) $(RECVFROM) $(RECVMSG) $(SELECT) $(SEND) $(SENDMSG) $(SENDTO) $(SETSOCKOPT) $(SHUTDOWN) $(SOCKATMARK) $(SOCKET) $(SOCKETPAIR)



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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#top Makefile.sol¶

SELECT ALL

# Project: Project
# Makefile created

GCC         = gcc
INCS        = -DHAVE_SOCKATMARK=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        = -lsocket -lnsl
LIBDIRS     =
LDFLAGS     = $(LIBDIRS) $(LIBS)
RM          = rm -f
MKDCMD      = mkdir -p

ACCEPT_TCP  = accept-tcp
ACCEPT_UNIX = accept-unix
BIND        = bind
CONNECT_TCP = connect-tcp
CONNECT_UNIX= connect-unix
GETPEERNAME = getpeername
GETSOCKNAME = getsockname
GETSOCKOPT  = getsockopt
INADDR_ANY  = INADDR_ANY
INADDR_NONE = INADDR_NONE
IPPROTO_ICMP= IPPROTO_ICMP
IPPROTO_RAW_RECV= IPPROTO_RAW-recv
IPPROTO_RAW_SEND= IPPROTO_RAW-send
LISTEN      = listen
RECV        = recv
RECVFROM    = recvfrom
RECVMSG     = recvmsg
SELECT      = select
SEND        = send
SENDMSG     = sendmsg
SENDTO      = sendto
SETSOCKOPT  = setsockopt
SHUTDOWN    = shutdown
SOCKATMARK  = sockatmark
SOCKET      = socket
SOCKETPAIR  = socketpair



all: objdir make

objdir:
	$(MKDCMD) obj/

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

#make: $(ACCEPT_TCP)
#make: $(ACCEPT_UNIX)
#make: $(BIND)
#make: $(CONNECT_TCP)
#make: $(CONNECT_UNIX)
#make: $(GETPEERNAME)
#make: $(GETSOCKNAME)
#make: $(GETSOCKOPT)
#make: $(INADDR_ANY)
#make: $(INADDR_NONE)
#make: $(IPPROTO_ICMP)
#make: $(IPPROTO_RAW_RECV)
#make: $(IPPROTO_RAW_SEND)
#make: $(LISTEN)
#make: $(RECV)
#make: $(RECVFROM)
#make: $(RECVMSG)
#make: $(SELECT)
#make: $(SEND)
#make: $(SENDMSG)
#make: $(SENDTO)
#make: $(SETSOCKOPT)
#make: $(SHUTDOWN)
#make: $(SOCKATMARK)
#make: $(SOCKET)
#make: $(SOCKETPAIR)
make: $(ACCEPT_TCP) $(ACCEPT_UNIX) $(BIND) $(CONNECT_TCP) $(CONNECT_UNIX) $(GETPEERNAME) $(GETSOCKNAME) $(GETSOCKOPT) $(INADDR_ANY) $(INADDR_NONE) $(IPPROTO_ICMP) $(IPPROTO_RAW_RECV) $(IPPROTO_RAW_SEND) $(LISTEN) $(RECV) $(RECVFROM) $(RECVMSG) $(SELECT) $(SEND) $(SENDMSG) $(SENDTO) $(SETSOCKOPT) $(SHUTDOWN) $(SOCKATMARK) $(SOCKET) $(SOCKETPAIR)



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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

$(SOCKETPAIR): $(SOCKETPAIR).o
	$(GCC) -o $(SOCKETPAIR) obj/$(SOCKETPAIR).o $(LDFLAGS)
$(SOCKETPAIR).o:
	$(GCC) -o obj/$(SOCKETPAIR).o -c $(SOCKETPAIR).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        = -lsocket
LIBDIRS     = -L/boot/system/lib
LDFLAGS     = $(LIBDIRS) $(LIBS)
RM          = rm -f
MKDCMD      = mkdir -p

ACCEPT_TCP  = accept-tcp
ACCEPT_UNIX = accept-unix
BIND        = bind
CONNECT_TCP = connect-tcp
CONNECT_UNIX= connect-unix
GETPEERNAME = getpeername
GETSOCKNAME = getsockname
GETSOCKOPT  = getsockopt
INADDR_ANY  = INADDR_ANY
INADDR_NONE = INADDR_NONE
IPPROTO_ICMP= IPPROTO_ICMP
IPPROTO_RAW_RECV= IPPROTO_RAW-recv
IPPROTO_RAW_SEND= IPPROTO_RAW-send
LISTEN      = listen
RECV        = recv
RECVFROM    = recvfrom
RECVMSG     = recvmsg
SELECT      = select
SEND        = send
SENDMSG     = sendmsg
SENDTO      = sendto
SETSOCKOPT  = setsockopt
SHUTDOWN    = shutdown
SOCKATMARK  = sockatmark
SOCKET      = socket
SOCKETPAIR  = socketpair



all: objdir make

objdir:
	$(MKDCMD) obj/

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

#make: $(ACCEPT_TCP)
#make: $(ACCEPT_UNIX)
#make: $(BIND)
#make: $(CONNECT_TCP)
#make: $(CONNECT_UNIX)
#make: $(GETPEERNAME)
#make: $(GETSOCKNAME)
#make: $(GETSOCKOPT)
#make: $(INADDR_ANY)
#make: $(INADDR_NONE)
#make: $(IPPROTO_ICMP)
#make: $(IPPROTO_RAW_RECV)
#make: $(IPPROTO_RAW_SEND)
#make: $(LISTEN)
#make: $(RECV)
#make: $(RECVFROM)
#make: $(RECVMSG)
#make: $(SELECT)
#make: $(SEND)
#make: $(SENDMSG)
#make: $(SENDTO)
#make: $(SETSOCKOPT)
#make: $(SHUTDOWN)
#make: $(SOCKATMARK)
#make: $(SOCKET)
#make: $(SOCKETPAIR)
make: $(ACCEPT_TCP) $(ACCEPT_UNIX) $(BIND) $(CONNECT_TCP) $(CONNECT_UNIX) $(GETPEERNAME) $(GETSOCKNAME) $(GETSOCKOPT) $(INADDR_ANY) $(INADDR_NONE) $(IPPROTO_ICMP) $(IPPROTO_RAW_RECV) $(IPPROTO_RAW_SEND) $(LISTEN) $(RECV) $(RECVFROM) $(RECVMSG) $(SELECT) $(SEND) $(SENDMSG) $(SENDTO) $(SETSOCKOPT) $(SHUTDOWN) $(SOCKATMARK) $(SOCKET) $(SOCKETPAIR)



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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#top Makefile.win¶

SELECT ALL

# Project: Project
# Makefile created

GCC         = gcc
INCS        = -DHAVE_SOCKATMARK=1 -DNEED_SOCKADDR_UN=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        = -lwsock32
LIBDIRS     =
LDFLAGS     = $(LIBDIRS) $(LIBS)
RM          = del /q /s
MKDCMD      = mkdir

ACCEPT_TCP  = accept-tcp
ACCEPT_UNIX = accept-unix
BIND        = bind
CONNECT_TCP = connect-tcp
CONNECT_UNIX= connect-unix
GETPEERNAME = getpeername
GETSOCKNAME = getsockname
GETSOCKOPT  = getsockopt
INADDR_ANY  = INADDR_ANY
INADDR_NONE = INADDR_NONE
IPPROTO_ICMP= IPPROTO_ICMP
IPPROTO_RAW_RECV= IPPROTO_RAW-recv
IPPROTO_RAW_SEND= IPPROTO_RAW-send
LISTEN      = listen
RECV        = recv
RECVFROM    = recvfrom
RECVMSG     = recvmsg
SELECT      = select
SEND        = send
SENDMSG     = sendmsg
SENDTO      = sendto
SETSOCKOPT  = setsockopt
SHUTDOWN    = shutdown
SOCKATMARK  = sockatmark
SOCKET      = socket
SOCKETPAIR  = socketpair



all: make

objdir:
	$(MKDCMD) obj\

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

#make: $(ACCEPT_TCP)
#make: $(ACCEPT_UNIX)
#make: $(BIND)
#make: $(CONNECT_TCP)
#make: $(CONNECT_UNIX)
#make: $(GETPEERNAME)
#make: $(GETSOCKNAME)
#make: $(GETSOCKOPT)
#make: $(INADDR_ANY)
#make: $(INADDR_NONE)
#make: $(IPPROTO_ICMP)
#make: $(IPPROTO_RAW_RECV)
#make: $(IPPROTO_RAW_SEND)
#make: $(LISTEN)
#make: $(RECV)
#make: $(RECVFROM)
#make: $(RECVMSG)
#make: $(SELECT)
#make: $(SEND)
#make: $(SENDMSG)
#make: $(SENDTO)
#make: $(SETSOCKOPT)
#make: $(SHUTDOWN)
#make: $(SOCKATMARK)
#make: $(SOCKET)
#make: $(SOCKETPAIR)
make: $(ACCEPT_TCP) $(ACCEPT_UNIX) $(BIND) $(CONNECT_TCP) $(CONNECT_UNIX) $(GETPEERNAME) $(GETSOCKNAME) $(GETSOCKOPT) $(INADDR_ANY) $(INADDR_NONE) $(IPPROTO_ICMP) $(IPPROTO_RAW_RECV) $(IPPROTO_RAW_SEND) $(LISTEN) $(RECV) $(RECVFROM) $(RECVMSG) $(SELECT) $(SEND) $(SENDMSG) $(SENDTO) $(SETSOCKOPT) $(SHUTDOWN) $(SOCKATMARK) $(SOCKET) $(SOCKETPAIR)



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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#top Predefined Constants¶

#top __FD_SETSIZE¶

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

/* Number of descriptors that can fit in an `fd_set'.  *:
#define __FD_SETSIZE        1024

#top __NFDBITS¶

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

/* Some versions of <linux/posix_types.h> define these macros.  */
#undef  __NFDBITS
/* It's easier to assume 8-bit bytes than to get CHAR_BIT.  */
#define __NFDBITS   (8 * sizeof (__fd_mask))

#top AF_FILE¶

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

/* Protocol families.  */
#define AF_FILE     PF_FILE

#top AF_INET¶

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

/* Protocol families.  */
#define AF_INET     PF_INET

#top AF_INET6¶

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

/* Protocol families.  */
#define AF_INET6    PF_INET6

#top AF_LOCAL¶

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

/* Protocol families.  */
#define AF_LOCAL    PF_LOCAL

#top AF_UNIX¶

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

/* Protocol families.  */
#define AF_UNIX     PF_UNIX

#top AF_UNSPEC¶

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

/* Address families.  */
#define AF_UNSPEC   PF_UNSPEC

#top EAGAIN¶

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

#define	EAGAIN		11	/* Try again */

#top EWOULDBLOCK¶

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

#define	EWOULDBLOCK	EAGAIN	/* Operation would block */

#top EPOLL_CTL_***¶

Deklaracja stałych EPOLL_CTL_*** znajduje się w pliku nagłówkowym sys/epoll.h.
Deklaracja stałych EPOLL_CTL_*** jest następująca:

/* Valid opcodes ( "op" parameter ) to issue to epoll_ctl().  */
#define EPOLL_CTL_ADD 1 /* Add a file decriptor to the interface.  */
#define EPOLL_CTL_DEL 2 /* Remove a file decriptor from the interface.  */
#define EPOLL_CTL_MOD 3 /* Change file decriptor epoll_event structure.  */

#top ICMP_FILTER¶

Deklaracja stałej ICMP_FILTER znajduje się w pliku nagłówkowym linux/icmp.h.
Deklaracja stałej ICMP_FILTER jest następująca:

/*
 *  constants for (set|get)sockopt
 */

#define ICMP_FILTER         1

#top IN_LOOPBACKNET¶

Deklaracja stałej IN_LOOPBACKNET znajduje się w pliku nagłówkowym netinet/in.h.
Deklaracja stałej IN_LOOPBACKNET jest następująca:

/* Network number for local host loopback.  */
#define IN_LOOPBACKNET      127

#top INADDR_ANY¶

Deklaracja stałej INADDR_ANY znajduje się w pliku nagłówkowym netinet/in.h.
Deklaracja stałej INADDR_ANY jest następująca:

/* Address to accept any incoming messages.  */
#define INADDR_ANY      ((in_addr_t) 0x00000000)

#top INADDR_BROADCAST¶

Deklaracja stałej INADDR_BROADCAST znajduje się w pliku nagłówkowym netinet/in.h.
Deklaracja stałej INADDR_BROADCAST jest następująca:

/* Address to send to all hosts.  */
#define INADDR_BROADCAST    ((in_addr_t) 0xffffffff)

#top INADDR_LOOPBACK¶

Deklaracja stałej INADDR_LOOPBACK znajduje się w pliku nagłówkowym netinet/in.h.
Deklaracja stałej INADDR_LOOPBACK jest następująca:

/* Address to loopback in software to local host.  */
#ifndef INADDR_LOOPBACK
# define INADDR_LOOPBACK    ((in_addr_t) 0x7f000001) :* Inet 127.0.0.1.  */
#endif

#top INADDR_NONE¶

Deklaracja stałej INADDR_NONE znajduje się w pliku nagłówkowym netinet/in.h.
Deklaracja stałej INADDR_NONE jest następująca:

/* Address indicating an error return.  */
#define INADDR_NONE     ((in_addr_t) 0xffffffff)

#top IP_MTU_DISCOVER¶

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

#define IP_MTU_DISCOVER    10   /* int; see below */

#top IPPROTO_***¶

Deklaracja stałych IPPROTO_*** znajduje się w pliku nagłówkowym netinet/in.h.
Deklaracja stałych IPPROTO_*** jest następująca:

/* Standard well-defined IP protocols.  */
enum
  {
    IPPROTO_IP = 0,    /* Dummy protocol for TCP.  */
#define IPPROTO_IP      IPPROTO_IP
    IPPROTO_HOPOPTS = 0,   /* IPv6 Hop-by-Hop options.  */
#define IPPROTO_HOPOPTS     IPPROTO_HOPOPTS
    IPPROTO_ICMP = 1,      /* Internet Control Message Protocol.  */
#define IPPROTO_ICMP        IPPROTO_ICMP
    IPPROTO_IGMP = 2,      /* Internet Group Management Protocol. */
#define IPPROTO_IGMP        IPPROTO_IGMP
    IPPROTO_IPIP = 4,      /* IPIP tunnels (older KA9Q tunnels use 94).  */
#define IPPROTO_IPIP        IPPROTO_IPIP
    IPPROTO_TCP = 6,       /* Transmission Control Protocol.  */
#define IPPROTO_TCP     IPPROTO_TCP
    IPPROTO_EGP = 8,       /* Exterior Gateway Protocol.  */
#define IPPROTO_EGP     IPPROTO_EGP
    IPPROTO_PUP = 12,      /* PUP protocol.  */
#define IPPROTO_PUP     IPPROTO_PUP
    IPPROTO_UDP = 17,      /* User Datagram Protocol.  */
#define IPPROTO_UDP     IPPROTO_UDP
    IPPROTO_IDP = 22,      /* XNS IDP protocol.  */
#define IPPROTO_IDP     IPPROTO_IDP
    IPPROTO_TP = 29,       /* SO Transport Protocol Class 4.  */
#define IPPROTO_TP      IPPROTO_TP
    IPPROTO_IPV6 = 41,     /* IPv6 header.  */
#define IPPROTO_IPV6        IPPROTO_IPV6
    IPPROTO_ROUTING = 43,  /* IPv6 routing header.  */
#define IPPROTO_ROUTING     IPPROTO_ROUTING
    IPPROTO_FRAGMENT = 44, /* IPv6 fragmentation header.  */
#define IPPROTO_FRAGMENT    IPPROTO_FRAGMENT
    IPPROTO_RSVP = 46,     /* Reservation Protocol.  */
#define IPPROTO_RSVP        IPPROTO_RSVP
    IPPROTO_GRE = 47,      /* General Routing Encapsulation.  */
#define IPPROTO_GRE     IPPROTO_GRE
    IPPROTO_ESP = 50,      /* encapsulating security payload.  */
#define IPPROTO_ESP     IPPROTO_ESP
    IPPROTO_AH = 51,       /* authentication header.  */
#define IPPROTO_AH      IPPROTO_AH
    IPPROTO_ICMPV6 = 58,   /* ICMPv6.  */
#define IPPROTO_ICMPV6      IPPROTO_ICMPV6
    IPPROTO_NONE = 59,     /* IPv6 no next header.  */
#define IPPROTO_NONE        IPPROTO_NONE
    IPPROTO_DSTOPTS = 60,  /* IPv6 destination options.  */
#define IPPROTO_DSTOPTS     IPPROTO_DSTOPTS
    IPPROTO_MTP = 92,      /* Multicast Transport Protocol.  */
#define IPPROTO_MTP     IPPROTO_MTP
    IPPROTO_ENCAP = 98,    /* Encapsulation Header.  */
#define IPPROTO_ENCAP       IPPROTO_ENCAP
    IPPROTO_PIM = 103,     /* Protocol Independent Multicast.  */
#define IPPROTO_PIM     IPPROTO_PIM
    IPPROTO_COMP = 108,    /* Compression Header Protocol.  */
#define IPPROTO_COMP        IPPROTO_COMP
    IPPROTO_SCTP = 132,    /* Stream Control Transmission Protocol.  */
#define IPPROTO_SCTP        IPPROTO_SCTP
    IPPROTO_RAW = 255,     /* Raw IP packets.  */
#define IPPROTO_RAW     IPPROTO_RAW
    IPPROTO_MAX
  };

#top IP_RECVERR¶

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

#define IP_RECVERR         11   /* bool */

#top IP_TTL¶

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

#define        IP_TTL          2       /* int; IP time to live.  */

#top MSG_***¶

Deklaracja stałych MSG_*** znajduje się w pliku nagłówkowym bits/socket.h.
Deklaracja stałych MSG_*** jest następująca:

/* Bits in the FLAGS argument to `send', `recv', et al.  */
enum
  {
    MSG_OOB             = 0x01, /* Process out-of-band data.  */
#define MSG_OOB         MSG_OOB
    MSG_PEEK            = 0x02, /* Peek at incoming messages.  */
#define MSG_PEEK        MSG_PEEK
    MSG_DONTROUTE       = 0x04, /* Don't use local routing.  */
#define MSG_DONTROUTE   MSG_DONTROUTE
#ifdef __USE_GNU
    /* DECnet uses a different name.  */
    MSG_TRYHARD         = MSG_DONTROUTE,
# define MSG_TRYHARD    MSG_DONTROUTE
#endif
    MSG_CTRUNC          = 0x08, /* Control data lost before delivery.  */
#define MSG_CTRUNC      MSG_CTRUNC
    MSG_PROXY           = 0x10, /* Supply or ask second address.  */
#define MSG_PROXY       MSG_PROXY
    MSG_TRUNC           = 0x20,
#define MSG_TRUNC       MSG_TRUNC
    MSG_DONTWAIT        = 0x40, /* Nonblocking IO.  */
#define MSG_DONTWAIT    MSG_DONTWAIT
    MSG_EOR             = 0x80, /* End of record.  */
#define MSG_EOR         MSG_EOR
    MSG_WAITALL         = 0x100, /* Wait for a full request.  */
#define MSG_WAITALL     MSG_WAITALL
    MSG_FIN             = 0x200,
#define MSG_FIN         MSG_FIN
    MSG_SYN             = 0x400,
#define MSG_SYN         MSG_SYN
    MSG_CONFIRM         = 0x800, /* Confirm path validity.  */
#define MSG_CONFIRM     MSG_CONFIRM
    MSG_RST             = 0x1000,
#define MSG_RST         MSG_RST
    MSG_ERRQUEUE        = 0x2000, /* Fetch message from error queue.  */
#define MSG_ERRQUEUE    MSG_ERRQUEUE
    MSG_NOSIGNAL        = 0x4000, /* Do not generate SIGPIPE.  */
#define MSG_NOSIGNAL    MSG_NOSIGNAL
    MSG_MORE            = 0x8000  /* Sender will send more.  */
#define MSG_MORE        MSG_MORE
  };

#top PF_FILE¶

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

/* Protocol families.  */
#define PF_FILE     PF_LOCAL :* Another non-standard name for PF_LOCAL.  *:

#top PF_INET¶

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

/* Protocol families.  */
#define PF_INET     2   /* IP protocol family.  */

#top PF_INET6¶

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

/* Protocol families.  */
#define PF_INET6    10  /* IP version 6.  */

#top PF_LOCAL¶

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

/* Protocol families.  */
#define PF_LOCAL    1   /* Local to host (pipes and file-domain).  */

#top PF_UNIX¶

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

/* Protocol families.  */
#define PF_UNIX     PF_LOCAL :* Old BSD name for PF_LOCAL.  *:

#top PF_UNSPEC¶

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

/* Protocol families.  */
#define PF_UNSPEC   0   /* Unspecified.  */

#top SHUT_***¶

Deklaracja stałych SHUT_*** znajduje się w pliku nagłówkowym sys/socket.h.
Deklaracja stałych SHUT_*** jest następująca:

/* The following constants should be used for the second parameter of
   `shutdown'.  */
enum
{
  SHUT_RD = 0,      /* No more receptions.  */
#define SHUT_RD     SHUT_RD
  SHUT_WR,      /* No more transmissions.  */
#define SHUT_WR     SHUT_WR
  SHUT_RDWR     /* No more receptions or transmissions.  */
#define SHUT_RDWR   SHUT_RDWR
};

#top SO_***¶

Deklaracja stałej SO_ACCEPTCONN znajduje się w pliku nagłówkowym asm/socket.h.
Deklaracja stałej SO_ACCEPTCONN jest następująca:

/* For setsockopt(2) */
#define SO_DEBUG        1
#define SO_REUSEADDR    2
#define SO_TYPE         3
#define SO_ERROR        4
#define SO_DONTROUTE    5
#define SO_BROADCAST    6
#define SO_SNDBUF       7
#define SO_RCVBUF       8
#define SO_SNDBUFFORCE  32
#define SO_RCVBUFFORCE  33
#define SO_KEEPALIVE    9
#define SO_OOBINLINE    10
#define SO_NO_CHECK     11
#define SO_PRIORITY     12
#define SO_LINGER       13
#define SO_BSDCOMPAT    14
[...]
#define SO_RCVLOWAT     18
#define SO_SNDLOWAT     19
#define SO_RCVTIMEO     20
#define SO_SNDTIMEO     21

[...]

#define SO_BINDTODEVICE 25

/* Socket filtering */
#define SO_ATTACH_FILTER        26
#define SO_DETACH_FILTER        27

#define SO_PEERNAME             28
#define SO_TIMESTAMP            29
#define SCM_TIMESTAMP           SO_TIMESTAMP

#define SO_ACCEPTCONN           30

[...]

#top enum __socket_type¶

Deklaracja stałych enum __socket_type znajduje się w pliku nagłówkowym bits/socket.h.
Deklaracja stałych enum __socket_type jest następująca:

/* Types of sockets.  */
enum __socket_type
{
  SOCK_STREAM = 1,      /* Sequenced, reliable, connection-based
                   byte streams.  */
#define SOCK_STREAM SOCK_STREAM
  SOCK_DGRAM = 2,       /* Connectionless, unreliable datagrams
                   of fixed maximum length.  */
#define SOCK_DGRAM SOCK_DGRAM
  SOCK_RAW = 3,         /* Raw protocol interface.  */
#define SOCK_RAW SOCK_RAW
  SOCK_RDM = 4,         /* Reliably-delivered messages.  */
#define SOCK_RDM SOCK_RDM
  SOCK_SEQPACKET = 5,       /* Sequenced, reliable, connection-based,
                   datagrams of fixed maximum length.  */
#define SOCK_SEQPACKET SOCK_SEQPACKET
  SOCK_PACKET = 10      /* Linux specific way of getting packets
                   at the dev level.  For writing rarp and
                   other similar things on the user level. */
#define SOCK_PACKET SOCK_PACKET
};

#top SOL_IP¶

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

/* To select the IP level.  */
#define SOL_IP  0

#top SOL_RAW¶

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

/* Socket level values.  Others are defined in the appropriate headers.

   XXX These definitions also should go into the appropriate headers as
   far as they are available.  */
#define SOL_RAW     255

#top SOL_SOCKET¶

Deklaracja stałej SOL_SOCKET znajduje się w pliku nagłówkowym asm/socket.h.
Deklaracja stałej SOL_SOCKET jest następująca:

/* For setsockopt(2) */
#define SOL_SOCKET  1

#top Datatypes / MACROS¶

#top __CONST_SOCKADDR_ARG¶

Definicja typu __CONST_SOCKADDR_ARG znajduje się w pliku nagłówkowym sys/socket.h.
Definicja typu __CONST_SOCKADDR_ARG jest następująca:

/* This is the type we use for generic socket address arguments.

   With GCC 2.7 and later, the funky union causes redeclarations or
   uses with any of the listed types to be allowed without complaint.
   G++ 2.7 does not support transparent unions so there we want the
   old-style declaration, too.  */
# define __CONST_SOCKADDR_ARG   __const struct sockaddr *

#top __fd_mask¶

Definicja typu __fd_mask znajduje się w pliku nagłówkowym sys/select.h.
Definicja typu __fd_mask jest następująca:

/* The fd_set member is required to be an array of longs.  */
typedef long int __fd_mask;

#top __ssize_t¶

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

__STD_TYPE __SSIZE_T_TYPE __ssize_t; /* Type of a byte count, or error.  */

#top __SOCKADDR_COMMON¶

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

/* This macro is used to declare the initial common members
   of the data types used for socket addresses, `struct sockaddr',
   `struct sockaddr_in', `struct sockaddr_un', etc.  *:
#define __SOCKADDR_COMMON(sa_prefix) \
  sa_family_t sa_prefix##family

#top __SOCKADDR_COMMON_SIZE¶

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

/* This macro is used to declare the initial common members
   of the data types used for socket addresses, `struct sockaddr',
   `struct sockaddr_in', `struct sockaddr_un', etc.  *:
#define __SOCKADDR_COMMON_SIZE  (sizeof (unsigned short int))

#top __SOCKADDR_ARG¶

Definicja typu __SOCKADDR_ARG znajduje się w pliku nagłówkowym sys/socket.h.
Definicja typu __SOCKADDR_ARG jest następująca:

/* This is the type we use for generic socket address arguments.

   With GCC 2.7 and later, the funky union causes redeclarations or
   uses with any of the listed types to be allowed without complaint.
   G++ 2.7 does not support transparent unions so there we want the
   old-style declaration, too.  */
# define __SOCKADDR_ARG     struct sockaddr *__restrict

#top __socklen_t¶

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

/* Duplicate info from sys/socket.h.  */
__STD_TYPE __U32_TYPE __socklen_t;

#top __suseconds_t¶

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

__STD_TYPE __SUSECONDS_T_TYPE __suseconds_t; /* Signed count of microseconds.  */

#top __time_t¶

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

__STD_TYPE __TIME_T_TYPE __time_t;        /* Seconds since the Epoch.  */

#top enum EPOLL_EVENTS¶

Definicja typu enum EPOLL_EVENTS znajduje się w pliku nagłówkowym sys/epoll.h.
Definicja typu enum EPOLL_EVENTS jest następująca:

enum EPOLL_EVENTS
  {
    EPOLLIN = 0x001,
#define EPOLLIN EPOLLIN
    EPOLLPRI = 0x002,
#define EPOLLPRI EPOLLPRI
    EPOLLOUT = 0x004,
#define EPOLLOUT EPOLLOUT
    EPOLLRDNORM = 0x040,
#define EPOLLRDNORM EPOLLRDNORM
    EPOLLRDBAND = 0x080,
#define EPOLLRDBAND EPOLLRDBAND
    EPOLLWRNORM = 0x100,
#define EPOLLWRNORM EPOLLWRNORM
    EPOLLWRBAND = 0x200,
#define EPOLLWRBAND EPOLLWRBAND
    EPOLLMSG = 0x400,
#define EPOLLMSG EPOLLMSG
    EPOLLERR = 0x008,
#define EPOLLERR EPOLLERR
    EPOLLHUP = 0x010,
#define EPOLLHUP EPOLLHUP
    EPOLLONESHOT = (1 << 30),
#define EPOLLONESHOT EPOLLONESHOT
    EPOLLET = (1 << 31)
#define EPOLLET EPOLLET
  };

#top epoll_data_t¶

Deklaracja typu epoll_data_t znajduje się w pliku nagłówkowym sys/epoll.h.
Deklaracja typu epoll_data_t jest następująca:

typedef union epoll_data
{
[...]
} epoll_data_t;

#top fd_set¶

Definicja typu fd_set znajduje się w pliku nagłówkowym sys/select.h.
Definicja typu fd_set jest następująca:

/* fd_set for select and pselect.  */
typedef struct
  {
    /* XPG4.2 requires this member name.  Otherwise avoid the name
       from the global namespace.  */
#ifdef __USE_XOPEN
    __fd_mask fds_bits[__FD_SETSIZE : __NFDBITS];
# define __FDS_BITS(set) ((set)->fds_bits)
#else
    __fd_mask __fds_bits[__FD_SETSIZE : __NFDBITS];
# define __FDS_BITS(set) ((set)->__fds_bits)
#endif
  } fd_set;

Powiązane:
in_addr_t, in_port_t, uint8_t, uint16_t, uint32_t,

#top in_addr_t¶

Definicja typu in_addr_t znajduje się w pliku nagłówkowym netinet/in.h.
Definicja typu in_addr_t jest następująca:

/* Internet address.  */
typedef uint32_t in_addr_t;

Powiązane:
in_addr_t, in_port_t, uint8_t, uint16_t, uint32_t,

#top in_port_t¶

Definicja typu in_port_t znajduje się w pliku nagłówkowym netinet/in.h.
Definicja typu in_port_t jest następująca:

/* Type to represent a port.  */
typedef uint16_t in_port_t;

Powiązane:
in_addr_t, in_port_t, uint8_t, uint16_t, uint32_t,

#top nfds_t¶

Definicja typu nfds_t znajduje się w pliku nagłówkowym sys/poll.h.
Definicja typu nfds_t jest następująca:

/* Type used for the number of file descriptors.  */
typedef unsigned long int nfds_t;

#top sa_family_t¶

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

/* POSIX.1g specifies this type name for the `sa_family' member.  */
typedef unsigned short int sa_family_t;

#top size_t¶

Definicja typu size_t znajduje się w pliku nagłówkowym /usr/lib/gcc/i386-redhat-linux/4.1.1/include/stddef.h.
Definicja typu size_t jest następująca:

/* Unsigned type of `sizeof' something.  */

/* Define this type if we are doing the whole job,
   or if we want this type in particular.  */
#if defined (_STDDEF_H) || defined (__need_size_t)
#ifndef __size_t__  /* BeOS */
#ifndef __SIZE_T__  /* Cray Unicos/Mk */
#ifndef _SIZE_T /* in case <sys/types.h> has defined it. */
#ifndef _SYS_SIZE_T_H
#ifndef _T_SIZE_
#ifndef _T_SIZE
#ifndef __SIZE_T
#ifndef _SIZE_T_
#ifndef _BSD_SIZE_T_
#ifndef _SIZE_T_DEFINED_
#ifndef _SIZE_T_DEFINED
#ifndef _BSD_SIZE_T_DEFINED_    /* Darwin */
#ifndef _SIZE_T_DECLARED    /* FreeBSD 5 */
#ifndef ___int_size_t_h
#ifndef _GCC_SIZE_T
#ifndef _SIZET_
#ifndef __size_t
#define __size_t__  /* BeOS */
#define __SIZE_T__  /* Cray Unicos/Mk */
#define _SIZE_T
#define _SYS_SIZE_T_H
#define _T_SIZE_
#define _T_SIZE
#define __SIZE_T
#define _SIZE_T_
#define _BSD_SIZE_T_
#define _SIZE_T_DEFINED_
#define _SIZE_T_DEFINED
#define _BSD_SIZE_T_DEFINED_    /* Darwin */
#define _SIZE_T_DECLARED    /* FreeBSD 5 */
#define ___int_size_t_h
#define _GCC_SIZE_T
#define _SIZET_
#if defined (__FreeBSD__) && (__FreeBSD__ >= 5)
/* __size_t is a typedef on FreeBSD 5!, must not trash it. */
#else
#define __size_t
#endif
#ifndef __SIZE_TYPE__
#define __SIZE_TYPE__ long unsigned int
#endif
#if !(defined (__GNUG__) && defined (size_t))
typedef __SIZE_TYPE__ size_t;
#ifdef __BEOS__
typedef long ssize_t;
#endif /* __BEOS__ */
#endif /* !(defined (__GNUG__) && defined (size_t)) */
#endif /* __size_t */
#endif /* _SIZET_ */
#endif /* _GCC_SIZE_T */
#endif /* ___int_size_t_h */
#endif /* _SIZE_T_DECLARED */
#endif /* _BSD_SIZE_T_DEFINED_ */
#endif /* _SIZE_T_DEFINED */
#endif /* _SIZE_T_DEFINED_ */
#endif /* _BSD_SIZE_T_ */
#endif /* _SIZE_T_ */
#endif /* __SIZE_T */
#endif /* _T_SIZE */
#endif /* _T_SIZE_ */
#endif /* _SYS_SIZE_T_H */
#endif /* _SIZE_T */
#endif /* __SIZE_T__ */
#endif /* __size_t__ */
#undef  __need_size_t
#endif /* _STDDEF_H or __need_size_t.  */

#top ssize_t¶

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

#ifndef __ssize_t_defined
typedef __ssize_t ssize_t;
# define __ssize_t_defined
#endif

#top socklen_t¶

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

/* Type for length arguments in socket calls.  */
#ifndef __socklen_t_defined
typedef __socklen_t socklen_t;
# define __socklen_t_defined
#endif

#top struct cmsghdr¶

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

/* Structure used for storage of ancillary data object information.  */
struct cmsghdr
  {
    size_t cmsg_len;        :* Length of data in cmsg_data plus length
                   of cmsghdr structure.
                   !! The type should be socklen_t but the
                   definition of the kernel is incompatible
                   with this.  */
    int cmsg_level;     /* Originating protocol.  */
    int cmsg_type;      /* Protocol specific type.  */
#if (!defined __STRICT_ANSI__ && __GNUC__ >= 2) || __STDC_VERSION__ >= 199901L
    __extension__ unsigned char __cmsg_data __flexarr; /* Ancillary data.  */
#endif
  };

#top struct epoll_event¶

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

struct epoll_event
{
  uint32_t events;  :* Epoll events */
  epoll_data_t data;    :* User data variable */
};

#top struct in_addr¶

Deklaracja struktury struct in_addr znajduje się w pliku nagłówkowym netinet/in.h.
Deklaracja struktury struct in_addr jest następująca:

/* Internet address.  */
struct in_addr
  {
    in_addr_t s_addr;
  };

#top struct in6_addr¶

Deklaracja struktury struct in6_addr znajduje się w pliku nagłówkowym netinet/in.h.
Deklaracja struktury struct in6_addr jest następująca:

/* IPv6 address */
struct in6_addr
  {
    union
      {
    uint8_t u6_addr8[16];
    uint16_t u6_addr16[8];
    uint32_t u6_addr32[4];
      } in6_u;
#define s6_addr         in6_u.u6_addr8
#define s6_addr16       in6_u.u6_addr16
#define s6_addr32       in6_u.u6_addr32
  };

#top struct iovec¶

Deklaracja struktury struct iovec znajduje się w pliku nagłówkowym bits/uio.h.
Deklaracja struktury struct iovec jest następująca:

/* Structure for scatter/gather I/O.  */
struct iovec
  {
    void *iov_base; /* Pointer to data.  */
    size_t iov_len; :* Length of data.  */
  };

#top struct linger¶

Deklaracja struktury struct linger znajduje się w pliku nagłówkowym bits/socket.h.
Deklaracja struktury struct linger jest następująca:

/* Structure used to manipulate the SO_LINGER option.  *:
struct linger
  {
    int l_onoff;        /* Nonzero to linger on close.  */
    int l_linger;       /* Time to linger.  */
  };

#top struct msghdr¶

Deklaracja struktury struct msghdr znajduje się w pliku nagłówkowym bits/socket.h.
Deklaracja struktury struct msghdr jest następująca:

/* Structure describing messages sent by
   `sendmsg' and received by `recvmsg'.  */
struct msghdr
  {
    void *msg_name;     /* Address to send to/receive from.  */
    socklen_t msg_namelen;  :* Length of address data.  */

    struct iovec *msg_iov;  :* Vector of data to send/receive into.  */
    size_t msg_iovlen;      :* Number of elements in the vector.  */

    void *msg_control;      /* Ancillary data (eg BSD filedesc passing). */
    size_t msg_controllen;  :* Ancillary data buffer length.
                   !! The type should be socklen_t but the
                   definition of the kernel is incompatible
                   with this.  */

    int msg_flags;      /* Flags on received message.  */
  };

#top struct pollfd¶

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

/* Data structure describing a polling request.  */
struct pollfd
  {
    int fd;         /* File descriptor to poll.  */
    short int events;       /* Types of events poller cares about.  */
    short int revents;      /* Types of events that actually occurred.  */
  };

#top struct sockaddr¶

Deklaracja struktury struct sockaddr znajduje się w pliku nagłówkowym bits/socket.h.
Deklaracja struktury struct sockaddr jest następująca:

/* Structure describing a generic socket address.  */
struct sockaddr
  {
    __SOCKADDR_COMMON (sa_);    :* Common data: address family and length.  */
    char sa_data[14];       /* Address data.  */
  };

#top struct sockaddr_in¶

Deklaracja struktury struct sockaddr_in znajduje się w pliku nagłówkowym netinet/in.h.
Deklaracja struktury struct sockaddr_in jest następująca:

/* Structure describing an Internet socket address.  */
struct sockaddr_in
  {
    __SOCKADDR_COMMON (sin_);
    in_port_t sin_port;         :* Port number.  */
    struct in_addr sin_addr;        :* Internet address.  */

    /* Pad to size of `struct sockaddr'.  *:
    unsigned char sin_zero[sizeof (struct sockaddr) -
               __SOCKADDR_COMMON_SIZE -
               sizeof (in_port_t) -
               sizeof (struct in_addr)];
  };

#top struct sockaddr_in6¶

Deklaracja struktury struct sockaddr_in6 znajduje się w pliku nagłówkowym netinet/in.h.
Deklaracja struktury struct sockaddr_in6 jest następująca:

/* Ditto, for IPv6.  */
struct sockaddr_in6
  {
    __SOCKADDR_COMMON (sin6_);
    in_port_t sin6_port;    :* Transport layer port # */
    uint32_t sin6_flowinfo; :* IPv6 flow information */
    struct in6_addr sin6_addr;  :* IPv6 address */
    uint32_t sin6_scope_id; :* IPv6 scope-id */
  };

#top struct sockaddr_un¶

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

/* Structure describing the address of an AF_LOCAL (aka AF_UNIX) socket.  *:
struct sockaddr_un
  {
    __SOCKADDR_COMMON (sun_);
    char sun_path[108];     /* Path name.  */
  };

#top struct timeval¶

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

/* A time value that is accurate to the nearest
   microsecond but also has a range of years.  */
struct timeval
  {
    __time_t tv_sec;        :* Seconds.  */
    __suseconds_t tv_usec;  :* Microseconds.  */
  };

#top uint8_t¶

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

/* Unsigned.  */
typedef unsigned char       uint8_t;

#top uint16_t¶

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

/* Unsigned.  */
typedef unsigned short int  uint16_t;

#top uint32_t¶

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

/* Unsigned.  */
#ifndef __uint32_t_defined
typedef unsigned int        uint32_t;
# define __uint32_t_defined
#endif

#top uint64_t¶

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

#if __WORDSIZE == 64
typedef unsigned long int   uint64_t;
#else
__extension__
typedef unsigned long long int  uint64_t;
#endif

#top union epoll_data¶

Deklaracja unii union epoll_data znajduje się w pliku nagłówkowym sys/epoll.h.
Deklaracja unii union epoll_data jest następująca:

typedef union epoll_data
{
  void *ptr;
  int fd;
  uint32_t u32;
  uint64_t u64;
} epoll_data_t;

#top Sockets Functions¶

#top accept¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | beej.us | gnu.org

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

/* Await a connection on socket FD.
   When a connection arrives, open a new socket to communicate with it,
   set *ADDR (which is *ADDR_LEN bytes long) to the address of the connecting
   peer and *ADDR_LEN to the address's actual length, and return the
   new socket's descriptor, or -1 for errors.

   This function is a cancellation point and therefore not marked with
   __THROW.  */
extern int accept (int __fd, __SOCKADDR_ARG __addr,
           socklen_t *__restrict __addr_len);

Powiązane:
accept(), bind(), listen(),

Opis:

Funkcja accept()

Argumenty:
int __fd -
__SOCKADDR_ARG __addr -
socklen_t *__restrict __addr_len -

Zwracana wartość:
int -

Example:
zawartość pliku accept-tcp.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, */

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
  #define WIN32_LEAN_AND_MEAN
  #include <winsock.h>     /* for SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, AF_INET, PF_INET, socket(), connect(), send(), recv(), sendto(), recvfrom(), shutdown(), */
                           /* for bind(), listen(), accept(), getsockname(), getsockopt(), setsockopt(), */
                           /* for in_addr_t, INADDR_ANY, INADDR_NONE, INADDR_BROADCAST, IPPROTO_TCP, IPPROTO_UDP, IPPROTO_ICMP, IPPROTO_RAW, */
                           /* for struct sockaddr_in, struct in_addr, inet_addr(), struct hostent, gethostbyname(), gethostbyaddr(), */
#else
  #include <sys/socket.h>  /* for bits/socket.h, SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, SOCK_PACKET, AF_UNIX, PF_UNIX, AF_FILE, PF_FILE, AF_INET, PF_INET, MSG_OOB, MSG_PEEK, MSG_DONTWAIT, struct msghdr, struct sockaddr, struct osockaddr, */
                           /* for socket(), bind(), getsockname(), connect(), getpeername(), send(), recv(), sendto(), recvfrom(), sendmsg(), recvmsg(), getsockopt(), setsockopt(), listen(), accept(), shutdown(), sockatmark(), */
  #include <sys/un.h>      /* for struct sockaddr_un, */
  #include <arpa/inet.h>   /* for netinet/in.h, in_addr_t, INADDR_ANY, INADDR_NONE, INADDR_BROADCAST, IPPROTO_TCP, IPPROTO_UDP, IPPROTO_ICMP, IPPROTO_RAW, */
                           /* for struct sockaddr_in, struct in_addr, inet_addr(), inet_ntoa(), inet_pton(), inet_ntop(), inet_aton(), inet_neta(), inet_net_ntop(), inet_net_pton(), */
  #include <netinet/in.h>  /* need in OpenBSD, for in_port_t, in_addr_t, struct in_addr, struct in6_addr, struct sockaddr_in, struct sockaddr_in6, ntohl(), ntohs(), htonl(), htons(), */
  #include <netinet/in_systm.h> /* need in OpenBSD for - typedef u_int32_t n_time - used in netinet/ip.h */
#endif

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
/* C:/Dev-CPP/bin/../lib/gcc/mingw32/3.4.2/../../../../include/winsock.h:32: */
/*typedef u_int SOCKET;*/
#else
typedef int SOCKET;
#endif

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
/* Sleep - Capital first letter */
/* #include <windows.h> + #include <winbase.h> +++ -lws2_32 */
#define sleep(time) Sleep(1000*time)
#define usleep(useconds) Sleep((useconds+999) / 1000)
#endif



int main(int argc, char **argv) {
	char *self;
	SOCKET lsock, csock;
	struct sockaddr_in listaddr, recvaddr;
	char ipaddr[16+1+5+1];
	int  iaport;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	int addrsize;
#else
	unsigned int addrsize;
#endif
	struct sockaddr_in addrinfo;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	int socksize;
#else
	socklen_t socksize;
#endif
	
	char buffdata[16384];
	int buffsend;
	int buffrecv;
	int result;
	int maxqueue;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<4) {
		printf("Usage: %s <tcp:ipaddr> <tcp:ipport> <max-queue>\n", argv[0]);
		return 0;
	}
	
	
	
	lsock=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (lsock!=INVALID_SOCKET)
#else
	if (lsock>=0)
#endif
	                   printf("%s: lsock=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP): lsock=%d if (osock>=0): Successful socket().\n", self, lsock);
	else               printf("%s: lsock=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP): lsock=%d if (osock>=0): else: Unable to socket(), Reason: %d:%s\n", self, lsock, errno, strerror(errno));
	
	
	
	memset(&listaddr,  0x00, sizeof(struct sockaddr_in));
	listaddr.sin_family = AF_INET;
	if (strncmp(argv[1],"0.0.0.0",7)==0) listaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	else                                 listaddr.sin_addr.s_addr = inet_addr(argv[1]);
	listaddr.sin_port = htons(atoi(argv[2]));
	
	
	
	result=bind(lsock, (struct sockaddr*)&listaddr, sizeof(struct sockaddr_in));
	if (result>=0) { printf("%s: result=bind(lsock, (struct sockaddr*)&listaddr, sizeof(struct sockaddr_in)): result=%d if (result>=0): Successful bind().\n", self, result); }
	else           { printf("%s: result=bind(lsock, (struct sockaddr*)&listaddr, sizeof(struct sockaddr_in)): result=%d if (result>=0): else: Unable bind(), Reason: %d:%s\n", self, result, errno, strerror(errno)); close(lsock); return 0; }
	
	
	
	maxqueue=atoi(argv[6]);
	
	result=listen(lsock, maxqueue);
	if (result>=0) { printf("%s: result=listen(lsock, maxqueue): result=%d if (result>=0): Successful listen().\n", self, result); }
	else           { printf("%s: result=listen(lsock, maxqueue): result=%d if (result>=0): else: Unable to listen(), Reason: %d:%s\n", self, result, errno, strerror(errno)); close(lsock); return 0; }
	
	
	
	addrsize = sizeof(struct sockaddr_in);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	while ((csock=accept(lsock,(struct sockaddr *)&recvaddr,&addrsize)) != INVALID_SOCKET )
#else
	while ((csock=accept(lsock,(struct sockaddr *)&recvaddr,&addrsize)) >= 0 )
#endif
	{
		
		memset(ipaddr, 0x00, sizeof(ipaddr));
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
		snprintf(ipaddr, sizeof(ipaddr), "%d.%d.%d.%d", (int)ntohl(recvaddr.sin_addr.s_addr&0x000000FF)>>24, (int)ntohl(recvaddr.sin_addr.s_addr&0x0000FF00)>>16, (int)ntohl(recvaddr.sin_addr.s_addr&0x00FF0000)>>8, (int)ntohl(recvaddr.sin_addr.s_addr&0xFF000000)>>0);
#else
		inet_ntop(AF_INET, &recvaddr.sin_addr, ipaddr, sizeof(ipaddr));
#endif
		iaport=ntohs(recvaddr.sin_port);
		printf("%s: while ((csock=accept(lsock,(struct sockaddr *)&recvaddr,&addrsize)) >= 0 ): csock=%d recvaddr=%s:%d addrsize=%d\n", self, csock, ipaddr, iaport, addrsize);
		
		
		
		socksize=sizeof(struct sockaddr_in);
		result=getsockname(csock, (struct sockaddr*)&addrinfo, &socksize);
		memset(ipaddr, 0x00, sizeof(ipaddr));
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
		snprintf(ipaddr, sizeof(ipaddr), "%d.%d.%d.%d", (int)ntohl(addrinfo.sin_addr.s_addr&0x000000FF)>>24, (int)ntohl(addrinfo.sin_addr.s_addr&0x0000FF00)>>16, (int)ntohl(addrinfo.sin_addr.s_addr&0x00FF0000)>>8, (int)ntohl(addrinfo.sin_addr.s_addr&0xFF000000)>>0);
#else
		inet_ntop(AF_INET, &addrinfo.sin_addr, ipaddr, sizeof(ipaddr));
#endif
		iaport=ntohs(addrinfo.sin_port);
		
		if (result>=0) printf("%s: result=getsockname(csock, (struct sockaddr*)&addrinfo=%s:%d, &socksize=%d): result=%d if (result>=0): Successful getsockname().\n", self, ipaddr, iaport, socksize, result);
		else           printf("%s: result=getsockname(csock, (struct sockaddr*)&addrinfo=%s:%d, &socksize=%d): result=%d if (result>=0): else: Unable to getsockname(), Reason: %d:%s\n", self, ipaddr, iaport, socksize, result, errno, strerror(errno));
		
		
		
		result=1;
		buffrecv=0;
		memset(buffdata, 0x00, sizeof(buffdata));
		/*while (result>0) {*/
			/** @name recv */
			result=recv(csock, buffdata+buffrecv, sizeof(buffdata)-buffrecv-1, 0);
			if (result>=0) printf("%s: result=recv(csock, buffdata+buffrecv, sizeof(buffdata)-buffrecv-1, 0): result=%d if (result>=0): Successful recv().\n", self, result);
			else           printf("%s: result=recv(csock, buffdata+buffrecv, sizeof(buffdata)-buffrecv-1, 0): result=%d if (result>=0): else: Unable to recv(), Reason: %d:%s\n", self, result, errno, strerror(errno));
			
			if (buffrecv+result>(int)sizeof(buffdata)) break; /* buffdata full */
			
			if      (result >0) buffrecv=buffrecv+result;
			else if (result==0) break;
			else                { close(csock); return 0; }
		/*}*/
		printf("%s: strlen(buffdata)=%lu buffrecv=%d buffdata=|%s|\n", self, (unsigned long int)strlen(buffdata), buffrecv, buffdata);
		
		
		
		/** @name send */
		buffsend=0;
		snprintf(buffdata+strlen(buffdata), sizeof(buffdata), "recvaddr=%s:%d\n", ipaddr, iaport);
		snprintf(buffdata+strlen(buffdata), sizeof(buffdata), "buffrecv(HTTP HEAD size)=%d\n", buffrecv);
		while (buffsend<(int)strlen(buffdata)) {
			result=send(csock, buffdata+buffsend, strlen(buffdata)-buffsend, 0);
			if (result>=0) printf("%s: result=send(csock, buffdata+buffsend, strlen(buffdata)-buffsend, 0): result=%d if (result>=0): Successful send().\n", self, result);
			else           printf("%s: result=send(csock, buffdata+buffsend, strlen(buffdata)-buffsend, 0): result=%d if (result>=0): else: Unable to send(), Reason: %d:%s\n", self, result, errno, strerror(errno));
			if      (result >0) buffsend=buffsend+result;
			else if (result==0) break;
			else                { close(csock); return 0; }
		}
		printf("%s: strlen(buffdata)=%lu buffsend=%d buffdata=|%s|\n", self, (unsigned long int)strlen(buffdata), buffsend, buffdata);
		
		close(csock);
		
	}
	
	
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (lsock!=INVALID_SOCKET) close(lsock);
#else
	if (lsock>=0) close(lsock);
#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/sockets/accept-tcp

program wyświetli informacje o sposobie uruchamiania programu:

Usage: /home/local/code/ansiccode/sockets/accept-tcp <tcp:ipaddr> <tcp:ipport> <max-queue>

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

/home/local/code/ansiccode/sockets/accept-tcp 0.0.0.0 2222 5

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

accept-tcp: lsock=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP): lsock=3 if (osock>=0): Successful socket().
accept-tcp: result=bind(lsock, (struct sockaddr*)&listaddr, sizeof(struct sockaddr_in)): result=0 if (result>=0): Successful bind().
accept-tcp: result=listen(lsock, maxqueue): result=0 if (result>=0): Successful listen().
accept-tcp: while ((csock=accept(lsock,(struct sockaddr *)&recvaddr,&addrsize)) >= 0 ): csock=4 recvaddr=127.0.0.1:46855 addrsize=16
accept-tcp: result=getsockname(csock, (struct sockaddr*)&addrinfo=127.0.0.1:2222, &socksize=16): result=0 if (result>=0): Successful getsockname().
accept-tcp: result=recv(csock, buffdata+buffrecv, sizeof(buffdata)-buffrecv-1, 0): result=65 if (result>=0): Successful recv().
accept-tcp: strlen(buffdata)=65 buffrecv=65 buffdata=|GET /globals.php HTTP/1.0
Host: 127.0.0.1
Connection: close

|
accept-tcp: result=send(csock, buffdata+buffsend, strlen(buffdata)-buffsend, 0): result=117 if (result>=0): Successful send().
accept-tcp: strlen(buffdata)=117 buffsend=117 buffdata=|GET /globals.php HTTP/1.0
Host: 127.0.0.1
Connection: close

recvaddr=127.0.0.1:2222
buffrecv(HTTP HEAD size)=65
|

Example:
zawartość pliku accept-unix.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, */

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
  #define WIN32_LEAN_AND_MEAN
  #include <winsock.h>     /* for SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, AF_INET, PF_INET, socket(), connect(), send(), recv(), sendto(), recvfrom(), shutdown(), */
                           /* for bind(), listen(), accept(), getsockname(), getsockopt(), setsockopt(), */
                           /* for in_addr_t, INADDR_ANY, INADDR_NONE, INADDR_BROADCAST, IPPROTO_TCP, IPPROTO_UDP, IPPROTO_ICMP, IPPROTO_RAW, */
                           /* for struct sockaddr_in, struct in_addr, inet_addr(), struct hostent, gethostbyname(), gethostbyaddr(), */
#else
  #include <sys/socket.h>  /* for bits/socket.h, SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, SOCK_PACKET, AF_UNIX, PF_UNIX, AF_FILE, PF_FILE, AF_INET, PF_INET, MSG_OOB, MSG_PEEK, MSG_DONTWAIT, struct msghdr, struct sockaddr, struct osockaddr, */
                           /* for socket(), bind(), getsockname(), connect(), getpeername(), send(), recv(), sendto(), recvfrom(), sendmsg(), recvmsg(), getsockopt(), setsockopt(), listen(), accept(), shutdown(), sockatmark(), */
  #include <sys/un.h>      /* for struct sockaddr_un, */
  #include <arpa/inet.h>   /* for netinet/in.h, in_addr_t, INADDR_ANY, INADDR_NONE, INADDR_BROADCAST, IPPROTO_TCP, IPPROTO_UDP, IPPROTO_ICMP, IPPROTO_RAW, */
                           /* for struct sockaddr_in, struct in_addr, inet_addr(), inet_ntoa(), inet_pton(), inet_ntop(), inet_aton(), inet_neta(), inet_net_ntop(), inet_net_pton(), */
  #include <netinet/in.h>  /* need in OpenBSD, for in_port_t, in_addr_t, struct in_addr, struct in6_addr, struct sockaddr_in, struct sockaddr_in6, ntohl(), ntohs(), htonl(), htons(), */
  #include <netinet/in_systm.h> /* need in OpenBSD for - typedef u_int32_t n_time - used in netinet/ip.h */
#endif

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
/* C:/Dev-CPP/bin/../lib/gcc/mingw32/3.4.2/../../../../include/winsock.h:32: */
/*typedef u_int SOCKET;*/
#else
typedef int SOCKET;
#endif

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
/* Sleep - Capital first letter */
/* #include <windows.h> + #include <winbase.h> +++ -lws2_32 */
#define sleep(time) Sleep(1000*time)
#define usleep(useconds) Sleep((useconds+999) / 1000)
#endif

#if defined(NEED_SOCKADDR_UN)
typedef unsigned short   sa_family_t;
/*#define __SOCKADDR_COMMON(sa_prefix) sa_family_t sa_prefix##family*/
/* Structure describing the address of an AF_LOCAL (aka AF_UNIX) socket.  */
struct sockaddr_un
  {
    /*__SOCKADDR_COMMON (sun_);*/
    sa_family_t sun_family;
    char sun_path[108];     /* Path name.  */
  };
#endif



int main(int argc, char **argv) {
	char *self;
	SOCKET lsock, csock;
	struct sockaddr_un listaddr, recvaddr;
	char unixaddr[1024];
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	int addrsize;
#else
	unsigned int addrsize;
#endif
	struct sockaddr_un addrinfo;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	int socksize;
#else
	socklen_t socksize;
#endif
	
	char buffdata[16384];
	int buffsend;
	int buffrecv;
	int result;
	int maxqueue;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<3) {
		printf("Usage: %s <unix:/path/to/socket> <max-queue>\n", argv[0]);
		return 0;
	}
	
	
	
	lsock=socket(AF_UNIX, SOCK_STREAM, 0);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (lsock!=INVALID_SOCKET)
#else
	if (lsock>=0)
#endif
	                   printf("%s: lsock=socket(AF_UNIX, SOCK_STREAM, 0): lsock=%d if (osock>=0): Successful socket().\n", self, lsock);
	else               printf("%s: lsock=socket(AF_UNIX, SOCK_STREAM, 0): lsock=%d if (osock>=0): else: Unable to socket(), Reason: %d:%s\n", self, lsock, errno, strerror(errno));
	
	
	
	memset(&listaddr, 0x00, sizeof(struct sockaddr_un));
	listaddr.sun_family=AF_UNIX;
	strncpy(listaddr.sun_path, argv[1], sizeof(listaddr.sun_path));
	
	
	
	unlink(listaddr.sun_path);
	result=bind(lsock, (struct sockaddr*)&listaddr, sizeof(listaddr.sun_family)+strlen(listaddr.sun_path));
	if (result>=0) { printf("%s: result=bind(lsock, (struct sockaddr*)&listaddr, sizeof(listaddr.sun_family)+strlen(listaddr.sun_path)): result=%d if (result>=0): Successful bind().\n", self, result); }
	else           { printf("%s: result=bind(lsock, (struct sockaddr*)&listaddr, sizeof(listaddr.sun_family)+strlen(listaddr.sun_path)): result=%d if (result>=0): else: Unable bind(), Reason: %d:%s\n", self, result, errno, strerror(errno)); close(lsock); return 0; }
	
	
	
	maxqueue=atoi(argv[6]);
	
	result=listen(lsock, maxqueue);
	if (result>=0) { printf("%s: result=listen(lsock, maxqueue): result=%d if (result>=0): Successful listen().\n", self, result); }
	else           { printf("%s: result=listen(lsock, maxqueue): result=%d if (result>=0): else: Unable to listen(), Reason: %d:%s\n", self, result, errno, strerror(errno)); close(lsock); return 0; }
	
	
	
	addrsize = sizeof(struct sockaddr_un);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	while ((csock=accept(lsock,(struct sockaddr*)&recvaddr,&addrsize)) != INVALID_SOCKET )
#else
	while ((csock=accept(lsock,(struct sockaddr*)&recvaddr,&addrsize)) >= 0 )
#endif
	{
		
		memset(unixaddr, 0x00, sizeof(unixaddr));
		strncpy(unixaddr, recvaddr.sun_path, sizeof(unixaddr));
		printf("%s: while ((csock=accept(lsock,(struct sockaddr*)&recvaddr,&addrsize)) >= 0 ): csock=%d recvaddr=%s addrsize=%d\n", self, csock, unixaddr, addrsize);
		
		
		
		socksize=sizeof(struct sockaddr_un);
		result=getsockname(csock, (struct sockaddr*)&addrinfo, &socksize);
		memset(unixaddr, 0x00, sizeof(unixaddr));
		strncpy(unixaddr, addrinfo.sun_path, sizeof(unixaddr));
		
		if (result>=0) printf("%s: result=getsockname(csock, (struct sockaddr*)&addrinfo=%s, &socksize=%d): result=%d if (result>=0): Successful getsockname().\n", self, unixaddr, socksize, result);
		else           printf("%s: result=getsockname(csock, (struct sockaddr*)&addrinfo=%s, &socksize=%d): result=%d if (result>=0): else: Unable to getsockname(), Reason: %d:%s\n", self, unixaddr, socksize, result, errno, strerror(errno));
		
		
		
		result=1;
		buffrecv=0;
		memset(buffdata, 0x00, sizeof(buffdata));
		/*while (result>0) {*/
			/** @name recv */
			result=recv(csock, buffdata+buffrecv, sizeof(buffdata)-buffrecv-1, 0);
			if (result>=0) printf("%s: result=recv(csock, buffdata+buffrecv, sizeof(buffdata)-buffrecv-1, 0): result=%d if (result>=0): Successful recv().\n", self, result);
			else           printf("%s: result=recv(csock, buffdata+buffrecv, sizeof(buffdata)-buffrecv-1, 0): result=%d if (result>=0): else: Unable to recv(), Reason: %d:%s\n", self, result, errno, strerror(errno));
			
			if (buffrecv+result>(int)sizeof(buffdata)) break; /* buffdata full */
			
			if      (result >0) buffrecv=buffrecv+result;
			else if (result==0) break;
			else                { close(csock); return 0; }
		/*}*/
		printf("%s: strlen(buffdata)=%lu buffrecv=%d buffdata=|%s|\n", self, (unsigned long int)strlen(buffdata), buffrecv, buffdata);
		
		
		
		/** @name send */
		buffsend=0;
		snprintf(buffdata+strlen(buffdata), sizeof(buffdata), "unixaddr=%s\n", unixaddr);
		snprintf(buffdata+strlen(buffdata), sizeof(buffdata), "buffrecv(HTTP HEAD size)=%d\n", buffrecv);
		while (buffsend<(int)strlen(buffdata)) {
			result=send(csock, buffdata+buffsend, strlen(buffdata)-buffsend, 0);
			if (result>=0) printf("%s: result=send(csock, buffdata+buffsend, strlen(buffdata)-buffsend, 0): result=%d if (result>=0): Successful send().\n", self, result);
			else           printf("%s: result=send(csock, buffdata+buffsend, strlen(buffdata)-buffsend, 0): result=%d if (result>=0): else: Unable to send(), Reason: %d:%s\n", self, result, errno, strerror(errno));
			if      (result >0) buffsend=buffsend+result;
			else if (result==0) break;
			else                { close(csock); return 0; }
		}
		printf("%s: strlen(buffdata)=%lu buffsend=%d buffdata=|%s|\n", self, (unsigned long int)strlen(buffdata), buffsend, buffdata);
		
		close(csock);
		
	}
	
	
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (lsock!=INVALID_SOCKET) close(lsock);
#else
	if (lsock>=0) close(lsock);
#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/sockets/accept-unix

program wyświetli informacje o sposobie uruchamiania programu:

Usage: /home/local/code/ansiccode/sockets/accept-unix <unix:/path/to/socket> <max-queue>

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

/home/local/code/ansiccode/sockets/accept-unix /home/local/code/ansiccode/sockets/accept-unix.sock 5

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

accept-unix: lsock=socket(AF_UNIX, SOCK_STREAM, 0): lsock=3 if (osock>=0): Successful socket().
accept-unix: result=bind(lsock, (struct sockaddr*)&listaddr, sizeof(listaddr.sun_family)+strlen(listaddr.sun_path)): result=0 if (result>=0): Successful bind().
accept-unix: result=listen(lsock, maxqueue): result=0 if (result>=0): Successful listen().
accept-unix: while ((csock=accept(lsock,(struct sockaddr*)&recvaddr,&addrsize)) >= 0 ): csock=4 recvaddr= addrsize=2
accept-unix: result=getsockname(csock, (struct sockaddr*)&addrinfo=/home/local/code/ansiccode/sockets/accept-unix.sock, &socksize=54): result=0 if (result>=0): Successful getsockname().
accept-unix: result=recv(csock, buffdata+buffrecv, sizeof(buffdata)-buffrecv-1, 0): result=107 if (result>=0): Successful recv().
accept-unix: strlen(buffdata)=107 buffrecv=107 buffdata=|GET /globals.php HTTP/1.0
Host: /home/local/code/ansiccode/sockets/accept-unix.sock
Connection: close

|
accept-unix: result=send(csock, buffdata+buffsend, strlen(buffdata)-buffsend, 0): result=197 if (result>=0): Successful send().
accept-unix: strlen(buffdata)=197 buffsend=197 buffdata=|GET /globals.php HTTP/1.0
Host: /home/local/code/ansiccode/sockets/accept-unix.sock
Connection: close

unixaddr=/home/local/code/ansiccode/sockets/accept-unix.sock
buffrecv(HTTP HEAD size)=107
|

#top bind¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | beej.us | gnu.org

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

/* Give the socket FD the local address ADDR (which is LEN bytes long).  */
extern int bind (int __fd, __CONST_SOCKADDR_ARG __addr, socklen_t __len)
     __THROW;

Powiązane:
accept(), bind(), listen(),

Opis:

Funkcja bind()

Argumenty:
int __fd -
__CONST_SOCKADDR_ARG __addr -
socklen_t __len -

Zwracana wartość:
int -

Example:
zawartość pliku bind.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, */

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
  #define WIN32_LEAN_AND_MEAN
  #include <winsock.h>     /* for SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, AF_INET, PF_INET, socket(), connect(), send(), recv(), sendto(), recvfrom(), shutdown(), */
                           /* for bind(), listen(), accept(), getsockname(), getsockopt(), setsockopt(), */
                           /* for in_addr_t, INADDR_ANY, INADDR_NONE, INADDR_BROADCAST, IPPROTO_TCP, IPPROTO_UDP, IPPROTO_ICMP, IPPROTO_RAW, */
                           /* for struct sockaddr_in, struct in_addr, inet_addr(), struct hostent, gethostbyname(), gethostbyaddr(), */
#else
  #include <sys/socket.h>  /* for bits/socket.h, SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, SOCK_PACKET, AF_UNIX, PF_UNIX, AF_FILE, PF_FILE, AF_INET, PF_INET, MSG_OOB, MSG_PEEK, MSG_DONTWAIT, struct msghdr, struct sockaddr, struct osockaddr, */
                           /* for socket(), bind(), getsockname(), connect(), getpeername(), send(), recv(), sendto(), recvfrom(), sendmsg(), recvmsg(), getsockopt(), setsockopt(), listen(), accept(), shutdown(), sockatmark(), */
  #include <sys/un.h>      /* for struct sockaddr_un, */
  #include <arpa/inet.h>   /* for netinet/in.h, in_addr_t, INADDR_ANY, INADDR_NONE, INADDR_BROADCAST, IPPROTO_TCP, IPPROTO_UDP, IPPROTO_ICMP, IPPROTO_RAW, */
                           /* for struct sockaddr_in, struct in_addr, inet_addr(), inet_ntoa(), inet_pton(), inet_ntop(), inet_aton(), inet_neta(), inet_net_ntop(), inet_net_pton(), */
  #include <netinet/in.h>  /* need in OpenBSD, for in_port_t, in_addr_t, struct in_addr, struct in6_addr, struct sockaddr_in, struct sockaddr_in6, ntohl(), ntohs(), htonl(), htons(), */
  #include <netinet/in_systm.h> /* need in OpenBSD for - typedef u_int32_t n_time - used in netinet/ip.h */
#endif

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
/* C:/Dev-CPP/bin/../lib/gcc/mingw32/3.4.2/../../../../include/winsock.h:32: */
/*typedef u_int SOCKET;*/
#else
typedef int SOCKET;
#endif

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
/* Sleep - Capital first letter */
/* #include <windows.h> + #include <winbase.h> +++ -lws2_32 */
#define sleep(time) Sleep(1000*time)
#define usleep(useconds) Sleep((useconds+999) / 1000)
#endif



int main(int argc, char **argv) {
	char *self;
	SOCKET osockaftcp;
	SOCKET osockafudp;
	SOCKET osockafunix;
	
	struct sockaddr_in tcpaddr;
	struct sockaddr_in udpaddr;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
#else
	struct sockaddr_un unixaddr;
#endif
	
	int result;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<6) {
		printf("Usage: %s <tcp:ipaddr> <tcp:ipport> <udp:ipaddr> <udp:ipport> <unix:/path/to/socket>\n", argv[0]);
		return 0;
	}
	
	
	
	osockaftcp=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockaftcp!=INVALID_SOCKET)
#else
	if (osockaftcp>=0)
#endif
	                   printf("%s: osockaftcp=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP): osockaftcp=%d if (osock>=0): Successful socket().\n", self, osockaftcp);
	else               printf("%s: osockaftcp=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP): osockaftcp=%d if (osock>=0): else: Unable to socket(), Reason: %d:%s\n", self, osockaftcp, errno, strerror(errno));
	
	
	osockafudp=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockafudp!=INVALID_SOCKET)
#else
	if (osockafudp>=0)
#endif
	                   printf("%s: osockafudp=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP): osockafudp=%d if (osockafudp>=0): Successful socket().\n", self, osockafudp);
	else               printf("%s: osockafudp=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP): osockafudp=%d if (osockafudp>=0): else: Unable to socket(), Reason: %d:%s\n", self, osockafudp, errno, strerror(errno));
	
	
	osockafunix=socket(AF_UNIX, SOCK_STREAM, 0);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockafunix!=INVALID_SOCKET)
#else
	if (osockafunix>=0)
#endif
	                    printf("%s: osockafunix=socket(AF_INET, SOCK_STREAM, 0): osockafunix=%d if (osockafunix>=0): Successful socket().\n", self, osockafunix);
	else                printf("%s: osockafunix=socket(AF_INET, SOCK_STREAM, 0): osockafunix=%d if (osockafunix>=0): else: Unable to socket(), Reason: %d:%s\n", self, osockafunix, errno, strerror(errno));
	
	
	
	memset(&tcpaddr,  0x00, sizeof(struct sockaddr_in));
	memset(&udpaddr,  0x00, sizeof(struct sockaddr_in));
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
#else
	memset(&unixaddr, 0x00, sizeof(struct sockaddr_un));
#endif
	
	
	tcpaddr.sin_family = AF_INET;
	if (strncmp(argv[1],"0.0.0.0",7)==0) tcpaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	else                                 tcpaddr.sin_addr.s_addr = inet_addr(argv[1]);
	tcpaddr.sin_port = htons(atoi(argv[2]));
	
	
	udpaddr.sin_family = AF_INET;
	if (strncmp(argv[3],"0.0.0.0",7)==0) udpaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	else                                 udpaddr.sin_addr.s_addr = inet_addr(argv[3]);
	udpaddr.sin_port = htons(atoi(argv[4]));
	
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
#else
	unixaddr.sun_family = AF_INET;
	strncpy(unixaddr.sun_path, argv[5], sizeof(unixaddr.sun_path));
#endif
	
	
	
	result=bind(osockaftcp, (struct sockaddr*)&tcpaddr, sizeof(struct sockaddr_in));
	if (result>=0) printf("%s: result=bind(osockaftcp, (struct sockaddr*)&tcpaddr, sizeof(struct sockaddr_in)): result=%d if (result>=0): Successful bind().\n", self, result);
	else           printf("%s: result=bind(osockaftcp, (struct sockaddr*)&tcpaddr, sizeof(struct sockaddr_in)): result=%d if (result>=0): else: Unable to bind(), Reason: %d:%s\n", self, result, errno, strerror(errno));
	
	
	result=bind(osockafudp, (struct sockaddr*)&udpaddr, sizeof(struct sockaddr_in));
	if (result>=0) printf("%s: result=bind(osockafudp, (struct sockaddr*)&udpaddr, sizeof(struct sockaddr_in)): result=%d if (result>=0): Successful bind().\n", self, result);
	else           printf("%s: result=bind(osockafudp, (struct sockaddr*)&udpaddr, sizeof(struct sockaddr_in)): result=%d if (result>=0): else: Unable to bind(), Reason: %d:%s\n", self, result, errno, strerror(errno));
	
	
	/** @name Unable to listen socket, Reason: 98:Address already in use */
	/** (NOTICE: FIX: remove socket if exists) (TODO: check if it is still using !!!) */
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
#else
	if (access(unixaddr.sun_path,F_OK)==0) { printf("%s: if (access(unixaddr.sun_path,F_OK)==0): previous socket exists: unlink(unixaddr.sun_path=%s)\n", self, unixaddr.sun_path); unlink(unixaddr.sun_path); }
	result=bind(osockafunix, (struct sockaddr*)&unixaddr, sizeof(unixaddr.sun_family)+strlen(unixaddr.sun_path));
	if (result>=0) printf("%s: result=bind(osockafunix, (struct sockaddr*)&unixaddr, sizeof(unixaddr.sun_family)+strlen(unixaddr.sun_path)): result=%d if (result>=0): Successful bind().\n", self, result);
	else           printf("%s: result=bind(osockafunix, (struct sockaddr*)&unixaddr, sizeof(unixaddr.sun_family)+strlen(unixaddr.sun_path)): result=%d if (result>=0): else: Unable to bind(), Reason: %d:%s\n", self, result, errno, strerror(errno));
#endif
	
	
	
	sleep(30);
	
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockaftcp!=INVALID_SOCKET) close(osockaftcp);
#else
	if (osockaftcp>=0) close(osockaftcp);
#endif
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockafudp!=INVALID_SOCKET) close(osockafudp);
#else
	if (osockafudp>=0) close(osockafudp);
#endif
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockafunix!=INVALID_SOCKET) close(osockafunix);
#else
	if (osockafunix>=0) close(osockafunix);
#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/sockets/bind

program wyświetli informacje o sposobie uruchamiania programu:

Usage: /home/local/code/ansiccode/sockets/bind <tcp:ipaddr> <tcp:ipport> <udp:ipaddr> <udp:ipport> <unix:/path/to/socket>

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

/home/local/code/ansiccode/sockets/bind 0.0.0.0 2222 0.0.0.0 2222 /home/local/code/ansiccode/sockets/bind

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

bind: osockaftcp=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP): osockaftcp=3 if (osock>=0): Successful socket().
bind: osockafudp=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP): osockafudp=4 if (osockafudp>=0): Successful socket().
bind: osockafunix=socket(AF_INET, SOCK_STREAM, 0): osockafunix=5 if (osockafunix>=0): Successful socket().
bind: result=bind(osockaftcp, (struct sockaddr*)&tcpaddr, sizeof(struct sockaddr_in)): result=0 if (result>=0): Successful bind().
bind: result=bind(osockafudp, (struct sockaddr*)&udpaddr, sizeof(struct sockaddr_in)): result=0 if (result>=0): Successful bind().
bind: if (access(unixaddr.sun_path,F_OK)==0): previous socket exists: unlink(unixaddr.sun_path=/home/local/code/ansiccode/sockets/bind)
bind: result=bind(osockafunix, (struct sockaddr*)&unixaddr, sizeof(unixaddr.sun_family)+strlen(unixaddr.sun_path)): result=-1 if (result>=0): else: Unable to bind(), Reason: 22:Invalid argument

#top connect¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | beej.us | gnu.org

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

/* Open a connection on socket FD to peer at ADDR (which LEN bytes long).
   For connectionless socket types, just set the default address to send to
   and the only address from which to accept transmissions.
   Return 0 on success, -1 for errors.

   This function is a cancellation point and therefore not marked with
   __THROW.  */
extern int connect (int __fd, __CONST_SOCKADDR_ARG __addr, socklen_t __len);

Powiązane:
connect(), poll(), recv(), select(), send(), shutdown(),

Opis:

Funkcja connect()

Argumenty:
int __fd -
__CONST_SOCKADDR_ARG __addr -
socklen_t __len -

Zwracana wartość:
int -

Example:
zawartość pliku connect-tcp.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, */

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
  #define WIN32_LEAN_AND_MEAN
  #include <winsock.h>     /* for SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, AF_INET, PF_INET, socket(), connect(), send(), recv(), sendto(), recvfrom(), shutdown(), */
                           /* for bind(), listen(), accept(), getsockname(), getsockopt(), setsockopt(), */
                           /* for in_addr_t, INADDR_ANY, INADDR_NONE, INADDR_BROADCAST, IPPROTO_TCP, IPPROTO_UDP, IPPROTO_ICMP, IPPROTO_RAW, */
                           /* for struct sockaddr_in, struct in_addr, inet_addr(), struct hostent, gethostbyname(), gethostbyaddr(), */
#else
  #include <sys/time.h>    /* for struct timezone, struct timeval, gettimeofday(), settimeofday(), utimes(), lutimes(), futimes(), futimesat(), */
  #include <sys/socket.h>  /* for bits/socket.h, SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, SOCK_PACKET, AF_UNIX, PF_UNIX, AF_FILE, PF_FILE, AF_INET, PF_INET, MSG_OOB, MSG_PEEK, MSG_DONTWAIT, struct msghdr, struct sockaddr, struct osockaddr, */
                           /* for socket(), bind(), getsockname(), connect(), getpeername(), send(), recv(), sendto(), recvfrom(), sendmsg(), recvmsg(), getsockopt(), setsockopt(), listen(), accept(), shutdown(), sockatmark(), */
  #include <sys/un.h>      /* for struct sockaddr_un, */
  #include <arpa/inet.h>   /* for netinet/in.h, in_addr_t, INADDR_ANY, INADDR_NONE, INADDR_BROADCAST, IPPROTO_TCP, IPPROTO_UDP, IPPROTO_ICMP, IPPROTO_RAW, */
                           /* for struct sockaddr_in, struct in_addr, inet_addr(), inet_ntoa(), inet_pton(), inet_ntop(), inet_aton(), inet_neta(), inet_net_ntop(), inet_net_pton(), */
  #include <netinet/in.h>  /* need in OpenBSD, for in_port_t, in_addr_t, struct in_addr, struct in6_addr, struct sockaddr_in, struct sockaddr_in6, ntohl(), ntohs(), htonl(), htons(), */
  #include <netinet/in_systm.h> /* need in OpenBSD for - typedef u_int32_t n_time - used in netinet/ip.h */
#endif

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
#define MSG_DONTWAIT              0
#else
/* MSG_DONTWAIT already defined */
#endif

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
#define SHUT_RD   SD_RECEIVE
#define SHUT_WR   SD_SEND
#define SHUT_RDWR SD_BOTH
#endif

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
/* C:/Dev-CPP/bin/../lib/gcc/mingw32/3.4.2/../../../../include/winsock.h:32: */
/*typedef u_int SOCKET;*/
#else
typedef int SOCKET;
#endif



int main(int argc, char **argv) {
	char *self;
	SOCKET osock;
	struct sockaddr_in destaddr;
	
	double tmoutrecv;
	struct timeval strtvrecv;
	fd_set fdsrd;
	
	char buffdata[16384];
	char buffline[128];
	char *linespch;
	int linesize;
	int buffsend;
	int buffrecv;
	int result;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<3) {
		printf("Usage: %s <tcp:ipaddr> <tcp:ipport>\n", argv[0]);
		return 0;
	}
	
	
	
	tmoutrecv=10;
	osock=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osock!=INVALID_SOCKET)
#else
	if (osock>=0)
#endif
	                   { printf("%s: osock=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP): osock=%d if (osock>=0): Successful socket().\n", self, osock); }
	else               { printf("%s: osock=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP): osock=%d if (osock>=0): else: Unable to socket(), Reason: %d:%s\n", self, osock, errno, strerror(errno)); return 0; }
	
	
	
	memset(&destaddr,  0x00, sizeof(struct sockaddr_in));
	destaddr.sin_family = AF_INET;
	destaddr.sin_addr.s_addr = inet_addr(argv[1]);
	destaddr.sin_port = htons(atoi(argv[2]));
	
	
	
	result=connect(osock, (struct sockaddr *)&destaddr, sizeof(struct sockaddr_in));
	if (result>=0) { printf("%s: result=connect(osock, (struct sockaddr *)&destaddr, sizeof(struct sockaddr_in)): result=%d if (result>=0): Successful connect().\n", self, result); }
	else           { printf("%s: result=connect(osock, (struct sockaddr *)&destaddr, sizeof(struct sockaddr_in)): result=%d if (result>=0): else: Unable to connect(), Reason: %d:%s\n", self, result, errno, strerror(errno)); close(osock); return 0; }
	
	
	
	/** @name create REQUEST */
	memset(buffdata, 0x00, sizeof(buffdata));
	strncat(buffdata, "GET /globals.php HTTP/1.0\r\n", sizeof(buffdata)-strlen(buffdata)-1);
	strncat(buffdata, "Host: ", sizeof(buffdata)-strlen(buffdata)-1); strncat(buffdata, argv[1], sizeof(buffdata)-strlen(buffdata)-1); strncat(buffdata, "\r\n", sizeof(buffdata)-strlen(buffdata)-1);
	strncat(buffdata, "Connection: close\r\n", sizeof(buffdata)-strlen(buffdata)-1);
	strncat(buffdata, "\r\n", sizeof(buffdata)-strlen(buffdata)-1);
	
	
	
	/** @name send REQUEST */
	buffsend=0;
	while (buffsend<(int)strlen(buffdata)) {
		result=send(osock, buffdata+buffsend, strlen(buffdata)-buffsend, 0);
		if (result>=0) printf("%s: result=send(osock, buffdata+buffsend, strlen(buffdata)-buffsend, 0): result=%d if (result>=0): Successful send().\n", self, result);
		else           printf("%s: result=send(osock, buffdata+buffsend, strlen(buffdata)-buffsend, 0): result=%d if (result>=0): else: Unable to send(), Reason: %d:%s\n", self, result, errno, strerror(errno));
		if      (result >0) buffsend=buffsend+result;
		else if (result==0) break;
		else                { close(osock); return 0; }
	}
	printf("%s: strlen(buffdata)=%u buffsend=%d buffdata=|%s|\n", self, strlen(buffdata), buffsend, buffdata);
	
	
	
	strtvrecv.tv_sec  = (int)tmoutrecv;
	strtvrecv.tv_usec = (int)( 1E6*(tmoutrecv-(double)strtvrecv.tv_sec) );
	
	FD_ZERO(&fdsrd);
	FD_SET(osock, &fdsrd);
	result=select(osock+1, &fdsrd, NULL, NULL, &strtvrecv);
	if (result==0) { printf("%s: result=select(osock+1, &fdsrd, NULL, NULL, &strtvrecv): result=%d if (result==0) return RES_TIMEOUT;\n", self, result);   return 2; }
	if (result <0) { printf("%s: result=select(osock+1, &fdsrd, NULL, NULL, &strtvrecv): result=%d if (result <0) return RES_SOCKERROR;\n", self, result); return 2; }
	
	
	
	/** @name recv HEAD */
	result=1;
	buffrecv=0;
	memset(buffdata, 0x00, sizeof(buffdata));
	while (result>0) {
		memset(buffline, 0x00, sizeof(buffline));
		result=recv(osock, buffline, sizeof(buffline), MSG_PEEK);
		if (result>=0) printf("%s: result=recv(osock, buffline, sizeof(buffline), MSG_PEEK): result=%d if (result>=0): Successful recv().\n", self, result);
		else           printf("%s: result=recv(osock, buffline, sizeof(buffline), MSG_PEEK): result=%d if (result>=0): else: Unable to recv(), Reason: %d:%s\n", self, result, errno, strerror(errno));
		
		linespch=NULL;
		linesize=0;
		if      (result>=0) { linespch=strstr(buffline, "\r\n"); if (linespch!=NULL) linesize=linespch-buffline+2; }
		else if (result==0) break;
		else                { close(osock); return 0; }
		
		if       (linesize==2) { printf("%s: result=recv(osock, buffline, strlen(buffdata)-buffrecv-1, 0): result=%d linesize=%d Found empty line\n", self, result, linesize); }
		else  if (linesize >0) { printf("%s: result=recv(osock, buffline, strlen(buffdata)-buffrecv-1, 0): result=%d linesize=%d\n", self, result, linesize); }
		else                   { printf("%s: result=recv(osock, buffline, strlen(buffdata)-buffrecv-1, 0): result=%d Unable to find new line (\\x0D\\x0A)\n", self, result); break; /*close(osock); return 0;*/ }
		
		result=recv(osock, buffdata+buffrecv, linesize, MSG_DONTWAIT);
		if (result>=0) printf("%s: result=recv(osock, buffdata+buffrecv, linesize, MSG_DONTWAIT): result=%d if (result>=0): Successful recv().\n", self, result);
		else           printf("%s: result=recv(osock, buffdata+buffrecv, linesize, MSG_DONTWAIT): result=%d if (result>=0): else: Unable to recv(), Reason: %d:%s\n", self, result, errno, strerror(errno));
		if      (result >0) buffrecv=buffrecv+result;
		else if (result==2) break;
		else                { close(osock); return 0; }
	}
	printf("%s: buffrecv=%d HEAD: buffdata=|%s|\n", self, buffrecv, buffdata);
	
	
	
	/** @name recv BODY */
	result=1;
	buffrecv=0;
	memset(buffdata, 0x00, sizeof(buffdata));
	while (result>0) {
		result=recv(osock, buffdata+buffrecv, sizeof(buffdata)-buffrecv-1, 0);
		printf("%s: result=%d buffrecv=%d\n", self, result, buffrecv);
		if (result>=0) printf("%s: result=recv(osock, buffdata+buffrecv, sizeof(buffdata)-buffrecv-1, 0): result=%d if (result>=0): Successful recv().\n", self, result);
		else           printf("%s: result=recv(osock, buffdata+buffrecv, sizeof(buffdata)-buffrecv-1, 0): result=%d if (result>=0): else: Unable to recv(), Reason: %d:%s\n", self, result, errno, strerror(errno));
		
		if (buffrecv+result>(int)sizeof(buffdata)) break; /* buffdata full */
		
		if      (result >0) buffrecv=buffrecv+result;
		else if (result==0) break;
		else                { close(osock); return 0; }
	}
	
	printf("%s: buffrecv=%d BODY: buffdata=|%s|\n", self, buffrecv, buffdata);
	
	result=shutdown(osock, SHUT_RD);
	if (result>=0) { printf("%s: result=shutdown(osock=%d, SHUT_RD=%d): result=%d if (result>=0): Successful shutdown().\n", self, osock, SHUT_RD, result); }
	else           { printf("%s: result=shutdown(osock=%d, SHUT_RD=%d): result=%d if (result>=0): else: Unable to shutdow(), Reason: %d:%s\n", self, osock, SHUT_RD, result, errno, strerror(errno)); }
	
	result=shutdown(osock, SHUT_WR);
	if (result>=0) { printf("%s: result=shutdown(osock=%d, SHUT_WR=%d): result=%d if (result>=0): Successful shutdown().\n", self, osock, SHUT_WR, result); }
	else           { printf("%s: result=shutdown(osock=%d, SHUT_WR=%d): result=%d if (result>=0): else: Unable to shutdown(), Reason: %d:%s\n", self, osock, SHUT_WR, result, errno, strerror(errno)); }
	
	result=shutdown(osock, SHUT_RDWR);
	if (result>=0) { printf("%s: result=shutdown(osock=%d, SHUT_RDWR=%d): result=%d if (result>=0): Successful shutdown().\n", self, osock, SHUT_RDWR, result); }
	else           { printf("%s: result=shutdown(osock=%d, SHUT_RDWR=%d): result=%d if (result>=0): else: Unable to shutdown(), Reason: %d:%s\n", self, osock, SHUT_RDWR, result, errno, strerror(errno)); }
	
	close(osock);
	
	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/sockets/connect-tcp

program wyświetli informacje o sposobie uruchamiania programu:

Usage: /home/local/code/ansiccode/sockets/connect-tcp <tcp:ipaddr> <tcp:ipport>

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

/home/local/code/ansiccode/sockets/connect-tcp 127.0.0.1 2222

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

connect-tcp: osock=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP): osock=3 if (osock>=0): Successful socket().
connect-tcp: result=connect(osock, (struct sockaddr *)&destaddr, sizeof(struct sockaddr_in)): result=0 if (result>=0): Successful connect().
connect-tcp: result=send(osock, buffdata+buffsend, strlen(buffdata)-buffsend, 0): result=65 if (result>=0): Successful send().
connect-tcp: strlen(buffdata)=65 buffsend=65 buffdata=|GET /globals.php HTTP/1.0
Host: 127.0.0.1
Connection: close

|
connect-tcp: result=recv(osock, buffline, sizeof(buffline), MSG_PEEK): result=117 if (result>=0): Successful recv().
connect-tcp: result=recv(osock, buffline, strlen(buffdata)-buffrecv-1, 0): result=117 linesize=27
connect-tcp: result=recv(osock, buffdata+buffrecv, linesize, MSG_DONTWAIT): result=27 if (result>=0): Successful recv().
connect-tcp: result=recv(osock, buffline, sizeof(buffline), MSG_PEEK): result=90 if (result>=0): Successful recv().
connect-tcp: result=recv(osock, buffline, strlen(buffdata)-buffrecv-1, 0): result=90 linesize=17
connect-tcp: result=recv(osock, buffdata+buffrecv, linesize, MSG_DONTWAIT): result=17 if (result>=0): Successful recv().
connect-tcp: result=recv(osock, buffline, sizeof(buffline), MSG_PEEK): result=73 if (result>=0): Successful recv().
connect-tcp: result=recv(osock, buffline, strlen(buffdata)-buffrecv-1, 0): result=73 linesize=19
connect-tcp: result=recv(osock, buffdata+buffrecv, linesize, MSG_DONTWAIT): result=19 if (result>=0): Successful recv().
connect-tcp: result=recv(osock, buffline, sizeof(buffline), MSG_PEEK): result=54 if (result>=0): Successful recv().
connect-tcp: result=recv(osock, buffline, strlen(buffdata)-buffrecv-1, 0): result=54 linesize=2 Found empty line
connect-tcp: result=recv(osock, buffdata+buffrecv, linesize, MSG_DONTWAIT): result=2 if (result>=0): Successful recv().
connect-tcp: result=recv(osock, buffline, sizeof(buffline), MSG_PEEK): result=52 if (result>=0): Successful recv().
connect-tcp: result=recv(osock, buffline, strlen(buffdata)-buffrecv-1, 0): result=52 Unable to find new line (\x0D\x0A)
connect-tcp: buffrecv=65 HEAD: buffdata=|GET /globals.php HTTP/1.0
Host: 127.0.0.1
Connection: close

|
connect-tcp: result=52 buffrecv=0
connect-tcp: result=recv(osock, buffdata+buffrecv, sizeof(buffdata)-buffrecv-1, 0): result=52 if (result>=0): Successful recv().
connect-tcp: result=0 buffrecv=52
connect-tcp: result=recv(osock, buffdata+buffrecv, sizeof(buffdata)-buffrecv-1, 0): result=0 if (result>=0): Successful recv().
connect-tcp: buffrecv=52 BODY: buffdata=|recvaddr=127.0.0.1:2222
buffrecv(HTTP HEAD size)=65
|
connect-tcp: result=shutdown(osock=3, SHUT_RD=0): result=0 if (result>=0): Successful shutdown().
connect-tcp: result=shutdown(osock=3, SHUT_WR=1): result=0 if (result>=0): Successful shutdown().
connect-tcp: result=shutdown(osock=3, SHUT_RDWR=2): result=-1 if (result>=0): else: Unable to shutdown(), Reason: 107:Transport endpoint is not connected

Example:
zawartość pliku connect-unix.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, */

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
  #define WIN32_LEAN_AND_MEAN
  #include <winsock.h>     /* for SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, AF_INET, PF_INET, socket(), connect(), send(), recv(), sendto(), recvfrom(), shutdown(), */
                           /* for bind(), listen(), accept(), getsockname(), getsockopt(), setsockopt(), */
                           /* for in_addr_t, INADDR_ANY, INADDR_NONE, INADDR_BROADCAST, IPPROTO_TCP, IPPROTO_UDP, IPPROTO_ICMP, IPPROTO_RAW, */
                           /* for struct sockaddr_in, struct in_addr, inet_addr(), struct hostent, gethostbyname(), gethostbyaddr(), */
#else
  #include <sys/time.h>    /* for struct timezone, struct timeval, gettimeofday(), settimeofday(), utimes(), lutimes(), futimes(), futimesat(), */
  #include <sys/socket.h>  /* for bits/socket.h, SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, SOCK_PACKET, AF_UNIX, PF_UNIX, AF_FILE, PF_FILE, AF_INET, PF_INET, MSG_OOB, MSG_PEEK, MSG_DONTWAIT, struct msghdr, struct sockaddr, struct osockaddr, */
                           /* for socket(), bind(), getsockname(), connect(), getpeername(), send(), recv(), sendto(), recvfrom(), sendmsg(), recvmsg(), getsockopt(), setsockopt(), listen(), accept(), shutdown(), sockatmark(), */
  #include <sys/un.h>      /* for struct sockaddr_un, */
  #include <arpa/inet.h>   /* for netinet/in.h, in_addr_t, INADDR_ANY, INADDR_NONE, INADDR_BROADCAST, IPPROTO_TCP, IPPROTO_UDP, IPPROTO_ICMP, IPPROTO_RAW, */
                           /* for struct sockaddr_in, struct in_addr, inet_addr(), inet_ntoa(), inet_pton(), inet_ntop(), inet_aton(), inet_neta(), inet_net_ntop(), inet_net_pton(), */
  #include <netinet/in.h>  /* need in OpenBSD, for in_port_t, in_addr_t, struct in_addr, struct in6_addr, struct sockaddr_in, struct sockaddr_in6, ntohl(), ntohs(), htonl(), htons(), */
  #include <netinet/in_systm.h> /* need in OpenBSD for - typedef u_int32_t n_time - used in netinet/ip.h */
#endif

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
#define MSG_DONTWAIT              0
#else
/* MSG_DONTWAIT already defined */
#endif

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
#define SHUT_RD   SD_RECEIVE
#define SHUT_WR   SD_SEND
#define SHUT_RDWR SD_BOTH
#endif

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
/* C:/Dev-CPP/bin/../lib/gcc/mingw32/3.4.2/../../../../include/winsock.h:32: */
/*typedef u_int SOCKET;*/
#else
typedef int SOCKET;
#endif

#if defined(NEED_SOCKADDR_UN)
typedef unsigned short   sa_family_t;
/*#define __SOCKADDR_COMMON(sa_prefix) sa_family_t sa_prefix##family*/
/* Structure describing the address of an AF_LOCAL (aka AF_UNIX) socket.  */
struct sockaddr_un
  {
    /*__SOCKADDR_COMMON (sun_);*/
    sa_family_t sun_family;
    char sun_path[108];     /* Path name.  */
  };
#endif



int main(int argc, char **argv) {
	char *self;
	SOCKET osock;
	struct sockaddr_un destaddr;
	
	double tmoutrecv;
	struct timeval strtvrecv;
	fd_set fdsrd;
	
	char buffdata[16384];
	char buffline[128];
	char *linespch;
	int linesize;
	int buffsend;
	int buffrecv;
	int result;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<2) {
		printf("Usage: %s <unix:/path/to/socket>\n", argv[0]);
		return 0;
	}
	
	
	
	tmoutrecv=10;
	osock=socket(AF_UNIX, SOCK_STREAM, 0);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osock!=INVALID_SOCKET)
#else
	if (osock>=0)
#endif
	                   { printf("%s: osock=socket(AF_UNIX, SOCK_STREAM, 0): osock=%d if (osock>=0): Successful socket().\n", self, osock); }
	else               { printf("%s: osock=socket(AF_UNIX, SOCK_STREAM, 0): osock=%d if (osock>=0): else: Unable to socket(), Reason: %d:%s\n", self, osock, errno, strerror(errno)); return 0; }
	
	
	
	memset(&destaddr,  0x00, sizeof(struct sockaddr_un));
	destaddr.sun_family=AF_UNIX;
	strncpy(destaddr.sun_path, argv[1], sizeof(destaddr.sun_path));
	
	
	
	result=connect(osock, (struct sockaddr*)&destaddr, sizeof(struct sockaddr_un));
	if (result>=0) { printf("%s: result=connect(osock, (struct sockaddr*)&destaddr, sizeof(struct sockaddr_un)): result=%d if (result>=0): Successful connect().\n", self, result); }
	else           { printf("%s: result=connect(osock, (struct sockaddr*)&destaddr, sizeof(struct sockaddr_un)): result=%d if (result>=0): else: Unable to connect(), Reason: %d:%s\n", self, result, errno, strerror(errno)); close(osock); return 0; }
	
	
	
	/** @name create REQUEST */
	memset(buffdata, 0x00, sizeof(buffdata));
	strncat(buffdata, "GET /globals.php HTTP/1.0\r\n", sizeof(buffdata)-strlen(buffdata)-1);
	strncat(buffdata, "Host: ", sizeof(buffdata)-strlen(buffdata)-1); strncat(buffdata, argv[1], sizeof(buffdata)-strlen(buffdata)-1); strncat(buffdata, "\r\n", sizeof(buffdata)-strlen(buffdata)-1);
	strncat(buffdata, "Connection: close\r\n", sizeof(buffdata)-strlen(buffdata)-1);
	strncat(buffdata, "\r\n", sizeof(buffdata)-strlen(buffdata)-1);
	
	
	
	/** @name send REQUEST */
	buffsend=0;
	while (buffsend<(int)strlen(buffdata)) {
		result=send(osock, buffdata+buffsend, strlen(buffdata)-buffsend, 0);
		if (result>=0) printf("%s: result=send(osock, buffdata+buffsend, strlen(buffdata)-buffsend, 0): result=%d if (result>=0): Successful send().\n", self, result);
		else           printf("%s: result=send(osock, buffdata+buffsend, strlen(buffdata)-buffsend, 0): result=%d if (result>=0): else: Unable to send(), Reason: %d:%s\n", self, result, errno, strerror(errno));
		if      (result >0) buffsend=buffsend+result;
		else if (result==0) break;
		else                { close(osock); return 0; }
	}
	printf("%s: strlen(buffdata)=%u buffsend=%d buffdata=|%s|\n", self, strlen(buffdata), buffsend, buffdata);
	
	
	
	strtvrecv.tv_sec  = (int)tmoutrecv;
	strtvrecv.tv_usec = (int)( 1E6*(tmoutrecv-(double)strtvrecv.tv_sec) );
	
	FD_ZERO(&fdsrd);
	FD_SET(osock, &fdsrd);
	result=select(osock+1, &fdsrd, NULL, NULL, &strtvrecv);
	if (result==0) { printf("%s: result=select(osock+1, &fdsrd, NULL, NULL, &strtvrecv): result=%d if (result==0) return RES_TIMEOUT;\n", self, result);   return 2; }
	if (result <0) { printf("%s: result=select(osock+1, &fdsrd, NULL, NULL, &strtvrecv): result=%d if (result <0) return RES_SOCKERROR;\n", self, result); return 2; }
	
	
	
	/** @name recv HEAD */
	result=1;
	buffrecv=0;
	memset(buffdata, 0x00, sizeof(buffdata));
	while (result>0) {
		memset(buffline, 0x00, sizeof(buffline));
		result=recv(osock, buffline, sizeof(buffline), MSG_PEEK);
		if (result>=0) printf("%s: result=recv(osock, buffline, sizeof(buffline), MSG_PEEK): result=%d if (result>=0): Successful recv().\n", self, result);
		else           printf("%s: result=recv(osock, buffline, sizeof(buffline), MSG_PEEK): result=%d if (result>=0): else: Unable to recv(), Reason: %d:%s\n", self, result, errno, strerror(errno));
		
		linespch=NULL;
		linesize=0;
		if      (result>=0) { linespch=strstr(buffline, "\r\n"); if (linespch!=NULL) linesize=linespch-buffline+2; }
		else if (result==0) break;
		else                { close(osock); return 0; }
		
		if       (linesize==2) { printf("%s: result=recv(osock, buffline, strlen(buffdata)-buffrecv-1, 0): result=%d linesize=%d Found empty line\n", self, result, linesize); break; }
		else  if (linesize >0) { printf("%s: result=recv(osock, buffline, strlen(buffdata)-buffrecv-1, 0): result=%d linesize=%d\n", self, result, linesize); }
		else                   { printf("%s: result=recv(osock, buffline, strlen(buffdata)-buffrecv-1, 0): result=%d Unable to find new line (\\x0D\\x0A)\n", self, result); break; /*close(osock); return 0;*/ }
		
		result=recv(osock, buffdata+buffrecv, linesize, MSG_DONTWAIT);
		if (result>=0) printf("%s: result=recv(osock, buffdata+buffrecv, linesize, MSG_DONTWAIT): result=%d if (result>=0): Successful recv().\n", self, result);
		else           printf("%s: result=recv(osock, buffdata+buffrecv, linesize, MSG_DONTWAIT): result=%d if (result>=0): else: Unable to recv(), Reason: %d:%s\n", self, result, errno, strerror(errno));
		if      (result >0) buffrecv=buffrecv+result;
		else if (result==2) break;
		else                { close(osock); return 0; }
	}
	printf("%s: buffrecv=%d HEAD: buffdata=|%s|\n", self, buffrecv, buffdata);
	
	
	
	/** @name recv BODY */
	result=1;
	buffrecv=0;
	memset(buffdata, 0x00, sizeof(buffdata));
	while (result>0) {
		result=recv(osock, buffdata+buffrecv, sizeof(buffdata)-buffrecv-1, 0);
		printf("%s: result=%d buffrecv=%d\n", self, result, buffrecv);
		if (result>=0) printf("%s: result=recv(osock, buffdata+buffrecv, sizeof(buffdata)-buffrecv-1, 0): result=%d if (result>=0): Successful recv().\n", self, result);
		else           printf("%s: result=recv(osock, buffdata+buffrecv, sizeof(buffdata)-buffrecv-1, 0): result=%d if (result>=0): else: Unable to recv(), Reason: %d:%s\n", self, result, errno, strerror(errno));
		
		if (buffrecv+result>(int)sizeof(buffdata)) break; /* buffdata full */
		
		if      (result >0) buffrecv=buffrecv+result;
		else if (result==0) break;
		else                { close(osock); return 0; }
	}
	
	printf("%s: buffrecv=%d BODY: buffdata=|%s|\n", self, buffrecv, buffdata);
	
	result=shutdown(osock, SHUT_RD);
	if (result>=0) { printf("%s: result=shutdown(osock=%d, SHUT_RD=%d): result=%d if (result>=0): Successful shutdown().\n", self, osock, SHUT_RD, result); }
	else           { printf("%s: result=shutdown(osock=%d, SHUT_RD=%d): result=%d if (result>=0): else: Unable to shutdow(), Reason: %d:%s\n", self, osock, SHUT_RD, result, errno, strerror(errno)); }
	
	result=shutdown(osock, SHUT_WR);
	if (result>=0) { printf("%s: result=shutdown(osock=%d, SHUT_WR=%d): result=%d if (result>=0): Successful shutdown().\n", self, osock, SHUT_WR, result); }
	else           { printf("%s: result=shutdown(osock=%d, SHUT_WR=%d): result=%d if (result>=0): else: Unable to shutdown(), Reason: %d:%s\n", self, osock, SHUT_WR, result, errno, strerror(errno)); }
	
	result=shutdown(osock, SHUT_RDWR);
	if (result>=0) { printf("%s: result=shutdown(osock=%d, SHUT_RDWR=%d): result=%d if (result>=0): Successful shutdown().\n", self, osock, SHUT_RDWR, result); }
	else           { printf("%s: result=shutdown(osock=%d, SHUT_RDWR=%d): result=%d if (result>=0): else: Unable to shutdown(), Reason: %d:%s\n", self, osock, SHUT_RDWR, result, errno, strerror(errno)); }
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osock!=INVALID_SOCKET) close(osock);
#else
	if (osock>=0) close(osock);
#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/sockets/connect-unix

program wyświetli informacje o sposobie uruchamiania programu:

Usage: /home/local/code/ansiccode/sockets/connect-unix <unix:/path/to/socket>

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

/home/local/code/ansiccode/sockets/connect-unix /home/local/code/ansiccode/sockets/accept-unix.sock

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

connect-unix: osock=socket(AF_UNIX, SOCK_STREAM, 0): osock=3 if (osock>=0): Successful socket().
connect-unix: result=connect(osock, (struct sockaddr*)&destaddr, sizeof(struct sockaddr_un)): result=0 if (result>=0): Successful connect().
connect-unix: result=send(osock, buffdata+buffsend, strlen(buffdata)-buffsend, 0): result=107 if (result>=0): Successful send().
connect-unix: strlen(buffdata)=107 buffsend=107 buffdata=|GET /globals.php HTTP/1.0
Host: /home/local/code/ansiccode/sockets/accept-unix.sock
Connection: close

|
connect-unix: result=recv(osock, buffline, sizeof(buffline), MSG_PEEK): result=128 if (result>=0): Successful recv().
connect-unix: result=recv(osock, buffline, strlen(buffdata)-buffrecv-1, 0): result=128 linesize=27
connect-unix: result=recv(osock, buffdata+buffrecv, linesize, MSG_DONTWAIT): result=27 if (result>=0): Successful recv().
connect-unix: result=recv(osock, buffline, sizeof(buffline), MSG_PEEK): result=128 if (result>=0): Successful recv().
connect-unix: result=recv(osock, buffline, strlen(buffdata)-buffrecv-1, 0): result=128 linesize=59
connect-unix: result=recv(osock, buffdata+buffrecv, linesize, MSG_DONTWAIT): result=59 if (result>=0): Successful recv().
connect-unix: result=recv(osock, buffline, sizeof(buffline), MSG_PEEK): result=111 if (result>=0): Successful recv().
connect-unix: result=recv(osock, buffline, strlen(buffdata)-buffrecv-1, 0): result=111 linesize=19
connect-unix: result=recv(osock, buffdata+buffrecv, linesize, MSG_DONTWAIT): result=19 if (result>=0): Successful recv().
connect-unix: result=recv(osock, buffline, sizeof(buffline), MSG_PEEK): result=92 if (result>=0): Successful recv().
connect-unix: result=recv(osock, buffline, strlen(buffdata)-buffrecv-1, 0): result=92 linesize=2 Found empty line
connect-unix: buffrecv=105 HEAD: buffdata=|GET /globals.php HTTP/1.0
Host: /home/local/code/ansiccode/sockets/accept-unix.sock
Connection: close
|
connect-unix: result=92 buffrecv=0
connect-unix: result=recv(osock, buffdata+buffrecv, sizeof(buffdata)-buffrecv-1, 0): result=92 if (result>=0): Successful recv().
connect-unix: result=0 buffrecv=92
connect-unix: result=recv(osock, buffdata+buffrecv, sizeof(buffdata)-buffrecv-1, 0): result=0 if (result>=0): Successful recv().
connect-unix: buffrecv=92 BODY: buffdata=|
unixaddr=/home/local/code/ansiccode/sockets/accept-unix.sock
buffrecv(HTTP HEAD size)=107
|
connect-unix: result=shutdown(osock=3, SHUT_RD=0): result=0 if (result>=0): Successful shutdown().
connect-unix: result=shutdown(osock=3, SHUT_WR=1): result=0 if (result>=0): Successful shutdown().
connect-unix: result=shutdown(osock=3, SHUT_RDWR=2): result=0 if (result>=0): Successful shutdown().

#top epoll_create¶

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

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

/* Creates an epoll instance.  Returns an fd for the new instance.
   The "size" parameter is a hint specifying the number of file
   descriptors to be associated with the new instance.  The fd
   returned by epoll_create() should be closed with close().  */
extern int epoll_create (int __size) __THROW;

Powiązane:
epoll_create(), epoll_ctl(), epoll_wait(),

Opis:

Funkcja epoll_create()

Argumenty:
int __size -

Zwracana wartość:
int -

#top epoll_ctl¶

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

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

/* Manipulate an epoll instance "epfd". Returns 0 in case of success,
   -1 in case of error ( the "errno" variable will contain the
   specific error code ) The "op" parameter is one of the EPOLL_CTL_*
   constants defined above. The "fd" parameter is the target of the
   operation. The "event" parameter describes which events the caller
   is interested in and any associated user data.  */
extern int epoll_ctl (int __epfd, int __op, int __fd,
              struct epoll_event *__event) __THROW;

Powiązane:
epoll_create(), epoll_ctl(), epoll_wait(),

Opis:

Funkcja epoll_ctl()

Argumenty:
int __epfd -
int __op -

/* Valid opcodes ( "op" parameter ) to issue to epoll_ctl(). */

EPOLL_CTL_ADD - Add a file decriptor to the interface.
EPOLL_CTL_DEL - Remove a file decriptor from the interface.
EPOLL_CTL_MOD - Change file decriptor epoll_event structure.

int __fd -
struct epoll_event *__event -

Zwracana wartość:
int -

Example:
zawartość pliku epoll_ctl.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:

program wyświetli informacje o sposobie uruchamiania programu:

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

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

#top epoll_wait¶

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

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

/* Wait for events on an epoll instance "epfd". Returns the number of
   triggered events returned in "events" buffer. Or -1 in case of
   error with the "errno" variable set to the specific error code. The
   "events" parameter is a buffer that will contain triggered
   events. The "maxevents" is the maximum number of events to be
   returned ( usually size of "events" ). The "timeout" parameter
   specifies the maximum wait time in milliseconds (-1 == infinite).

   This function is a cancellation point and therefore not marked with
   __THROW.  */
extern int epoll_wait (int __epfd, struct epoll_event *__events,
               int __maxevents, int __timeout);

Powiązane:
epoll_create(), epoll_ctl(), epoll_wait(),

Opis:

Funkcja epoll_wait()

Argumenty:
int __epfd -
struct epoll_event *__events -
int __maxevents -
int __timeout -

Zwracana wartość:
int -

#top getpeername¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | beej.us | gnu.org

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

/* Put the address of the peer connected to socket FD into *ADDR
   (which is *LEN bytes long), and its actual length into *LEN.  */
extern int getpeername (int __fd, __SOCKADDR_ARG __addr,
            socklen_t *__restrict __len) __THROW;

Powiązane:
getsockname(), getpeername(),

Opis:

Funkcja getpeername()

Argumenty:
int __fd -
__SOCKADDR_ARG __addr -
socklen_t *__restrict __len -

Zwracana wartość:
int -

#top getsockname¶

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

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

/* Put the address of the peer connected to socket FD into *ADDR
   (which is *LEN bytes long), and its actual length into *LEN.  */
extern int getpeername (int __fd, __SOCKADDR_ARG __addr,
            socklen_t *__restrict __len) __THROW;

Powiązane:
getsockname(), getpeername(),

Opis:

Funkcja getsockname()

Argumenty:
int __fd -
__SOCKADDR_ARG __addr -
socklen_t *__restrict __len -

Zwracana wartość:
int -

Example:
zawartość pliku getsockname.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, */

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
  #define WIN32_LEAN_AND_MEAN
  #include <winsock.h>     /* for SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, AF_INET, PF_INET, socket(), connect(), send(), recv(), sendto(), recvfrom(), shutdown(), */
                           /* for bind(), listen(), accept(), getsockname(), getsockopt(), setsockopt(), */
                           /* for in_addr_t, INADDR_ANY, INADDR_NONE, INADDR_BROADCAST, IPPROTO_TCP, IPPROTO_UDP, IPPROTO_ICMP, IPPROTO_RAW, */
                           /* for struct sockaddr_in, struct in_addr, inet_addr(), struct hostent, gethostbyname(), gethostbyaddr(), */
#else
  #include <sys/socket.h>  /* for bits/socket.h, SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, SOCK_PACKET, AF_UNIX, PF_UNIX, AF_FILE, PF_FILE, AF_INET, PF_INET, MSG_OOB, MSG_PEEK, MSG_DONTWAIT, struct msghdr, struct sockaddr, struct osockaddr, */
                           /* for socket(), bind(), getsockname(), connect(), getpeername(), send(), recv(), sendto(), recvfrom(), sendmsg(), recvmsg(), getsockopt(), setsockopt(), listen(), accept(), shutdown(), sockatmark(), */
  #include <sys/un.h>      /* for struct sockaddr_un, */
  #include <arpa/inet.h>   /* for netinet/in.h, in_addr_t, INADDR_ANY, INADDR_NONE, INADDR_BROADCAST, IPPROTO_TCP, IPPROTO_UDP, IPPROTO_ICMP, IPPROTO_RAW, */
                           /* for struct sockaddr_in, struct in_addr, inet_addr(), inet_ntoa(), inet_pton(), inet_ntop(), inet_aton(), inet_neta(), inet_net_ntop(), inet_net_pton(), */
  #include <netinet/in.h>  /* need in OpenBSD, for in_port_t, in_addr_t, struct in_addr, struct in6_addr, struct sockaddr_in, struct sockaddr_in6, ntohl(), ntohs(), htonl(), htons(), */
  #include <netinet/in_systm.h> /* need in OpenBSD for - typedef u_int32_t n_time - used in netinet/ip.h */
#endif

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
/* C:/Dev-CPP/bin/../lib/gcc/mingw32/3.4.2/../../../../include/winsock.h:32: */
/*typedef u_int SOCKET;*/
#else
typedef int SOCKET;
#endif



int main(int argc, char **argv) {
	char *self;
	SOCKET osockaftcp;
	SOCKET osockafudp;
	
	struct sockaddr_in tcpaddr;
	struct sockaddr_in udpaddr;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	int addrsize;
#else
	unsigned int addrsize;
#endif
	
	struct sockaddr_in addrinfo;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	int socksize;
#else
	socklen_t socksize;
#endif
	char ipaddr[16];
	int  ipport;
	
	int result;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<5) {
		printf("Usage: %s <tcp:ipaddr> <tcp:ipport> <udp:ipaddr> <udp:ipport>\n", argv[0]);
		printf("Examples:\n");
		printf("       %s 10.0.0.3 80 10.0.0.3 7\n", argv[0]);
		return 0;
	}
	
	
	
	osockaftcp=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockaftcp!=INVALID_SOCKET)
#else
	if (osockaftcp>=0)
#endif
	                   printf("%s: osockaftcp=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP): osockaftcp=%d if (osock>=0): Successful socket().\n", self, osockaftcp);
	else               printf("%s: osockaftcp=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP): osockaftcp=%d if (osock>=0): else: Unable to socket(), Reason: %d:%s\n", self, osockaftcp, errno, strerror(errno));
	
	osockafudp=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockafudp!=INVALID_SOCKET)
#else
	if (osockafudp>=0)
#endif
	                   printf("%s: osockafudp=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP): osockafudp=%d if (osockafudp>=0): Successful socket().\n", self, osockafudp);
	else               printf("%s: osockafudp=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP): osockafudp=%d if (osockafudp>=0): else: Unable to socket(), Reason: %d:%s\n", self, osockafudp, errno, strerror(errno));
	
	
	
	memset(&tcpaddr,  0x00, sizeof(struct sockaddr_in));
	memset(&udpaddr,  0x00, sizeof(struct sockaddr_in));
	
	tcpaddr.sin_family = AF_INET;
	if (strncmp(argv[1],"0.0.0.0",7)==0) tcpaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	else                                 tcpaddr.sin_addr.s_addr = inet_addr(argv[1]);
	tcpaddr.sin_port = htons(atoi(argv[2]));
	
	udpaddr.sin_family = AF_INET;
	if (strncmp(argv[3],"0.0.0.0",7)==0) udpaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	else                                 udpaddr.sin_addr.s_addr = inet_addr(argv[3]);
	udpaddr.sin_port = htons(atoi(argv[4]));
	
	
	
	result=connect(osockaftcp, (struct sockaddr*)&tcpaddr, sizeof(struct sockaddr_in));
	if (result>=0) printf("%s: result=connect(osockaftcp, (struct sockaddr*)&tcpaddr, sizeof(struct sockaddr_in)): result=%d if (result>=0): Successful connect().\n", self, result);
	else           printf("%s: result=connect(osockaftcp, (struct sockaddr*)&tcpaddr, sizeof(struct sockaddr_in)): result=%d if (result>=0): else: Unable to connect(), Reason: %d:%s\n", self, result, errno, strerror(errno));
	result=connect(osockafudp, (struct sockaddr*)&udpaddr, sizeof(struct sockaddr_in));
	if (result>=0) printf("%s: result=connect(osockafudp, (struct sockaddr*)&udpaddr, sizeof(struct sockaddr_in)): result=%d if (result>=0): Successful connect().\n", self, result);
	else           printf("%s: result=connect(osockafudp, (struct sockaddr*)&udpaddr, sizeof(struct sockaddr_in)): result=%d if (result>=0): else: Unable to connect(), Reason: %d:%s\n", self, result, errno, strerror(errno));
	
	
	
	memset(&addrinfo,  0x00, sizeof(struct sockaddr_in));
	socksize=sizeof(struct sockaddr_in);
	result=getsockname(osockaftcp, (struct sockaddr*)&addrinfo, &socksize);
	memset(ipaddr, 0x00, sizeof(ipaddr));
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	snprintf(ipaddr, sizeof(ipaddr), "%d.%d.%d.%d", (int)ntohl(addrinfo.sin_addr.s_addr&0x000000FF)>>24, (int)ntohl(addrinfo.sin_addr.s_addr&0x0000FF00)>>16, (int)ntohl(addrinfo.sin_addr.s_addr&0x00FF0000)>>8, (int)ntohl(addrinfo.sin_addr.s_addr&0xFF000000)>>0);
#else
	inet_ntop(AF_INET, &addrinfo.sin_addr, ipaddr, sizeof(ipaddr));
#endif
	ipport=ntohs(addrinfo.sin_port);
	
	if (result>=0) printf("%s: result=getsockname(osockaftcp, (struct sockaddr*)&addrinfo=%s:%d, &socksize=%d): result=%d if (result>=0): Successful getsockname().\n", self, ipaddr, ipport, socksize, result);
	else           printf("%s: result=getsockname(osockaftcp, (struct sockaddr*)&addrinfo=%s:%d, &socksize=%d): result=%d if (result>=0): else: Unable to getsockname(), Reason: %d:%s\n", self, ipaddr, ipport, socksize, result, errno, strerror(errno));
	
	
	
	memset(&addrinfo,  0x00, sizeof(struct sockaddr_in));
	socksize=sizeof(struct sockaddr_in);
	result=getpeername(osockaftcp, (struct sockaddr*)&addrinfo, &socksize);
	memset(ipaddr, 0x00, sizeof(ipaddr));
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	snprintf(ipaddr, sizeof(ipaddr), "%d.%d.%d.%d", (int)ntohl(addrinfo.sin_addr.s_addr&0x000000FF)>>24, (int)ntohl(addrinfo.sin_addr.s_addr&0x0000FF00)>>16, (int)ntohl(addrinfo.sin_addr.s_addr&0x00FF0000)>>8, (int)ntohl(addrinfo.sin_addr.s_addr&0xFF000000)>>0);
#else
	inet_ntop(AF_INET, &addrinfo.sin_addr, ipaddr, sizeof(ipaddr));
#endif
	ipport=ntohs(addrinfo.sin_port);
	
	if (result>=0) printf("%s: result=getpeername(osockaftcp, (struct sockaddr*)&addrinfo=%s:%d, &socksize=%d): result=%d if (result>=0): Successful getpeername().\n", self, ipaddr, ipport, socksize, result);
	else           printf("%s: result=getpeername(osockaftcp, (struct sockaddr*)&addrinfo=%s:%d, &socksize=%d): result=%d if (result>=0): else: Unable to getpeername(), Reason: %d:%s\n", self, ipaddr, ipport, socksize, result, errno, strerror(errno));
	
	
	
	/** @name UDP socket is not connected */
	memset(&addrinfo,  0x00, sizeof(struct sockaddr_in));
	addrsize=sizeof(struct sockaddr_in);
	result=getsockname(osockafudp, (struct sockaddr*)&addrinfo, &socksize);
	memset(ipaddr, 0x00, sizeof(ipaddr));
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	snprintf(ipaddr, sizeof(ipaddr), "%d.%d.%d.%d", (int)ntohl(addrinfo.sin_addr.s_addr&0x000000FF)>>24, (int)ntohl(addrinfo.sin_addr.s_addr&0x0000FF00)>>16, (int)ntohl(addrinfo.sin_addr.s_addr&0x00FF0000)>>8, (int)ntohl(addrinfo.sin_addr.s_addr&0xFF000000)>>0);
#else
	inet_ntop(AF_INET, &addrinfo.sin_addr, ipaddr, sizeof(ipaddr));
#endif
	ipport=ntohs(addrinfo.sin_port);
	
	if (result>=0) printf("%s: result=getsockname(osockafudp, (struct sockaddr*)&addrinfo=%s:%d, &socksize=%d): result=%d if (result>=0): Successful getsockname().\n", self, ipaddr, ipport, socksize, result);
	else           printf("%s: result=getsockname(osockafudp, (struct sockaddr*)&addrinfo=%s:%d, &socksize=%d): result=%d if (result>=0): else: Unable to getsockname(), Reason: %d:%s\n", self, ipaddr, ipport, socksize, result, errno, strerror(errno));
	
	
	
	socksize=sizeof(struct sockaddr_in);
	memset(&addrinfo,  0x00, sizeof(struct sockaddr_in));
	result=getpeername(osockafudp, (struct sockaddr*)&addrinfo, &socksize);
	memset(ipaddr, 0x00, sizeof(ipaddr));
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	snprintf(ipaddr, sizeof(ipaddr), "%d.%d.%d.%d", (int)ntohl(addrinfo.sin_addr.s_addr&0x000000FF)>>24, (int)ntohl(addrinfo.sin_addr.s_addr&0x0000FF00)>>16, (int)ntohl(addrinfo.sin_addr.s_addr&0x00FF0000)>>8, (int)ntohl(addrinfo.sin_addr.s_addr&0xFF000000)>>0);
#else
	inet_ntop(AF_INET, &addrinfo.sin_addr, ipaddr, sizeof(ipaddr));
#endif
	ipport=ntohs(addrinfo.sin_port);
	
	if (result>=0) printf("%s: result=getpeername(osockafudp, (struct sockaddr*)&addrinfo=%s:%d, &socksize=%d): result=%d if (result>=0): Successful getpeername().\n", self, ipaddr, ipport, socksize, result);
	else           printf("%s: result=getpeername(osockafudp, (struct sockaddr*)&addrinfo=%s:%d, &socksize=%d): result=%d if (result>=0): else: Unable to getpeername(), Reason: %d:%s\n", self, ipaddr, ipport, socksize, result, errno, strerror(errno));
	
	
	
	close(osockaftcp);
	close(osockafudp);
	
	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/sockets/getsockname

program wyświetli informacje o sposobie uruchamiania programu:

Usage: /home/local/code/ansiccode/sockets/getsockname <tcp:ipaddr> <tcp:ipport> <udp:ipaddr> <udp:ipport>
Examples:
       /home/local/code/ansiccode/sockets/getsockname 10.0.0.3 80 10.0.0.3 7

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

/home/local/code/ansiccode/sockets/getsockname 10.0.0.3 80 10.0.0.3 7

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

getsockname: osockaftcp=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP): osockaftcp=3 if (osock>=0): Successful socket().
getsockname: osockafudp=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP): osockafudp=4 if (osockafudp>=0): Successful socket().
getsockname: result=connect(osockaftcp, (struct sockaddr*)&tcpaddr, sizeof(struct sockaddr_in)): result=0 if (result>=0): Successful connect().
getsockname: result=connect(osockafudp, (struct sockaddr*)&udpaddr, sizeof(struct sockaddr_in)): result=0 if (result>=0): Successful connect().
getsockname: result=getsockname(osockaftcp, (struct sockaddr*)&addrinfo=10.0.0.3:52979, &socksize=16): result=0 if (result>=0): Successful getsockname().
getsockname: result=getpeername(osockaftcp, (struct sockaddr*)&addrinfo=10.0.0.3:80, &socksize=16): result=0 if (result>=0): Successful getpeername().
getsockname: result=getsockname(osockafudp, (struct sockaddr*)&addrinfo=10.0.0.3:49285, &socksize=16): result=0 if (result>=0): Successful getsockname().
getsockname: result=getpeername(osockafudp, (struct sockaddr*)&addrinfo=10.0.0.3:7, &socksize=16): result=0 if (result>=0): Successful getpeername().

#top getsockopt¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | beej.us | gnu.org

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

/* Put the current value for socket FD's option OPTNAME at protocol level LEVEL
   into OPTVAL (which is *OPTLEN bytes long), and set *OPTLEN to the value's
   actual length.  Returns 0 on success, -1 for errors.  */
extern int getsockopt (int __fd, int __level, int __optname,
               void *__restrict __optval,
               socklen_t *__restrict __optlen) __THROW;

Powiązane:
getsockopt(), setsockopt(),

Opis:

Funkcja getsockopt()

Argumenty:
int __fd -
int __level -

int __optname -

for __level SOL_RAW following __optname are defined:

ICMP_FILTER -

for __level SOL_IP following __optname are defined:
for __level IPPROTO_IP following __optname are defined:

for __level SOL_SOCKET following __optname are defined:

SO_DEBUG - Reports whether debugging information is being recorded. This option stores an int value. This is a boolean option.
SO_BINDTODEVICE -
SO_ATTACH_FILTER -
SO_DETACH_FILTER -
SO_TIMESTAMP -
SO_ACCEPTCONN - Reports whether socket listening is enabled. This option stores an int value.
SO_BROADCAST - Reports whether transmission of broadcast messages is supported, if this is supported by the protocol. This option stores an int value. This is a boolean option.
SO_REUSEADDR - Reports whether the rules used in validating addresses supplied to bind() should allow reuse of local addresses, if this is supported by the protocol. This option stores an int value. This is a boolean option.
SO_KEEPALIVE - Reports whether connections are kept active with periodic transmission of messages, if this is supported by the protocol. If the connected socket fails to respond to these messages, the connection is broken and processes writing to that socket are notified with a SIGPIPE signal. This option stores an int value. This is a boolean option.
SO_LINGER - Reports whether the socket lingers on close() if data is present. If SO_LINGER is set, the system blocks the process during close() until it can transmit the data or until the end of the interval indicated by the l_linger member, whichever comes first. If SO_LINGER is not specified, and close() is issued, the system handles the call in a way that allows the process to continue as quickly as possible. This option stores a linger structure.
SO_OOBINLINE - Reports whether the socket leaves received out-of-band data (data marked urgent) in line. This option stores an int value. This is a boolean option.
SO_SNDBUF - Reports send buffer size information. This option stores an int value.
SO_RCVBUF - Reports receive buffer size information. This option stores an int value.
SO_ERROR - Reports information about error status and clears it. This option stores an int value.
SO_TYPE - Reports the socket type. This option stores an int value.
SO_DONTROUTE - Reports whether outgoing messages bypass the standard routing facilities. The destination must be on a directly-connected network, and messages are directed to the appropriate network interface according to the destination address. The effect, if any, of this option depends on what protocol is in use. This option stores an int value. This is a boolean option.
SO_RCVLOWAT - Reports the minimum number of bytes to process for socket input operations. The default value for SO_RCVLOWAT is 1. If SO_RCVLOWAT is set to a larger value, blocking receive calls normally wait until they have received the smaller of the low water mark value or the requested amount. (They may return less than the low water mark if an error occurs, a signal is caught, or the type of data next in the receive queue is different than that returned, e.g. out of band data). This option stores an int value. Note that not all implementations allow this option to be retrieved.
SO_RCVTIMEO - Reports the timeout value for input operations. This option stores a timeval structure with the number of seconds and microseconds specifying the limit on how long to wait for an input operation to complete. If a receive operation has blocked for this much time without receiving additional data, it returns with a partial count or errno set to [EAGAIN] or [EWOULDBLOCK] if no data were received. The default for this option is zero, which indicates that a receive operation will not time out. Note that not all implementations allow this option to be retrieved.
SO_SNDLOWAT - Reports the minimum number of bytes to process for socket output operations. Non-blocking output operations will process no data if flow control does not allow the smaller of the send low water mark value or the entire request to be processed. This option stores an int value. Note that not all implementations allow this option to be retrieved.
SO_SNDTIMEO - Reports the timeout value specifying the amount of time that an output function blocks because flow control prevents data from being sent. If a send operation has blocked for this time, it returns with a partial count or with errno set to [EAGAIN] or [EWOULDBLOCK] if no data were sent. The default for this option is zero, which indicates that a send operation will not time out. The option stores a timeval structure. Note that not all implementations allow this option to be retrieved.

for __level IPPROTO_TCP following __optname are defined:

TCP_NODELAY -

for __level IPPROTO_UDP following __optname are defined:

void *__restrict __optval -
socklen_t *__restrict __optlen -

Zwracana wartość:
int -

Example:
zawartość pliku getsockopt.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, */

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
  #define WIN32_LEAN_AND_MEAN
  #include <winsock.h>     /* for SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, AF_INET, PF_INET, socket(), connect(), send(), recv(), sendto(), recvfrom(), shutdown(), */
                           /* for bind(), listen(), accept(), getsockname(), getsockopt(), setsockopt(), */
                           /* for in_addr_t, INADDR_ANY, INADDR_NONE, INADDR_BROADCAST, IPPROTO_TCP, IPPROTO_UDP, IPPROTO_ICMP, IPPROTO_RAW, */
                           /* for struct sockaddr_in, struct in_addr, inet_addr(), struct hostent, gethostbyname(), gethostbyaddr(), */
#else
  #include <fcntl.h>       /* for O_RDONLY, O_WRONLY, O_RDWR, O_CREAT, O_TRUNC, O_APPEND, F_GETFL, F_SETFL, O_NONBLOCK, fcntl(), open(), creat(), */
  #include <sys/time.h>    /* for struct timezone, struct timeval, gettimeofday(), settimeofday(), utimes(), lutimes(), futimes(), futimesat(), */
  #include <sys/socket.h>  /* for bits/socket.h, SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, SOCK_PACKET, AF_UNIX, PF_UNIX, AF_FILE, PF_FILE, AF_INET, PF_INET, MSG_OOB, MSG_PEEK, MSG_DONTWAIT, struct msghdr, struct sockaddr, struct osockaddr, */
                           /* for socket(), bind(), getsockname(), connect(), getpeername(), send(), recv(), sendto(), recvfrom(), sendmsg(), recvmsg(), getsockopt(), setsockopt(), listen(), accept(), shutdown(), sockatmark(), */
  #include <sys/un.h>      /* for struct sockaddr_un, */
  #include <arpa/inet.h>   /* for netinet/in.h, in_addr_t, INADDR_ANY, INADDR_NONE, INADDR_BROADCAST, IPPROTO_TCP, IPPROTO_UDP, IPPROTO_ICMP, IPPROTO_RAW, */
                           /* for struct sockaddr_in, struct in_addr, inet_addr(), inet_ntoa(), inet_pton(), inet_ntop(), inet_aton(), inet_neta(), inet_net_ntop(), inet_net_pton(), */
  #include <netinet/in.h>  /* need in OpenBSD, for in_port_t, in_addr_t, struct in_addr, struct in6_addr, struct sockaddr_in, struct sockaddr_in6, ntohl(), ntohs(), htonl(), htons(), */
  #include <netinet/in_systm.h> /* need in OpenBSD for - typedef u_int32_t n_time - used in netinet/ip.h */
  #include <netinet/ip.h>  /* for struct timestamp, struct iphdr, struct ip, struct ip_timestamp, IP_DF, */
#endif

/* This is added for compatibility with OS TCP/IP */
#ifndef TCP_NODELAY
/*/usr/include/netinet/tcp.h:40:#define   TCP_NODELAY      1*/      /* Don't delay send to coalesce packets  */
#define TCP_NODELAY                   1          /* Don't delay send to coalesce packets  */
#endif /* TCP_NODELAY */

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
/* C:/Dev-CPP/bin/../lib/gcc/mingw32/3.4.2/../../../../include/winsock.h:32: */
/*typedef u_int SOCKET;*/
#else
typedef int SOCKET;
#endif



int main(int argc, char **argv) {
	char *self;
	SOCKET osock;
	struct sockaddr_in destaddr;
	int result;
	
	double tmoutrecv;
	struct timeval strtvconn;
	fd_set fdsrd, fdswr;
	
	int flags;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	int argsize;
	u_long iMode;
#else
	unsigned int argsize;
#endif
	struct linger soling;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<3) {
		printf("Usage: %s <tcp:ipaddr> <tcp:ipport>\n", argv[0]);
		printf("Examples:\n");
		printf("       %s 127.0.0.1 22\n", argv[0]);
		printf("       %s 127.0.0.1 80\n", argv[0]);
		printf("       %s 127.0.0.1 1234\n", argv[0]);
		return 0;
	}
	
	osock=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osock==INVALID_SOCKET)
#else
	if (osock>=0)
#endif
	                   printf("%s: osock=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP): osock=%d if (osock>=0): Successful socket().\n", self, osock);
	else               printf("%s: osock=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP): osock=%d if (osock>=0): else: Unable to socket(), Reason: %d:%s\n", self, osock, errno, strerror(errno));
	
	
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	iMode=1;
	result=ioctlsocket(osock,FIONBIO,&iMode);
	if (result>=0) printf("%s: result=ioctlsocket(osock=%d,FIONBIO=%lu,&iMode=%lu): result=%d if (osock>=0): Successful getsockopt().\n", self, osock, (long unsigned int)FIONBIO, iMode, result);
	else           printf("%s: result=ioctlsocket(osock=%d,FIONBIO=%lu,&iMode=%lu): result=%d if (osock>=0): else: Unable getsockopt(), Reason: %d:%s\n", self, osock, (long unsigned int)FIONBIO, iMode, result, errno, strerror(errno));
#else
	flags = fcntl(osock,F_GETFL,0);
	result=fcntl(osock,F_SETFL,flags|O_NONBLOCK);
	if (result>=0) printf("%s: result=fcntl(osock=%d,F_SETFL=%d,flags|O_NONBLOCK=%d): result=%d if (osock>=0): Successful getsockopt().\n", self, osock, F_SETFL, flags|O_NONBLOCK, result);
	else           printf("%s: result=fcntl(osock=%d,F_SETFL=%d,flags|O_NONBLOCK=%d): result=%d if (osock>=0): else: Unable getsockopt(), Reason: %d:%s\n", self, osock, F_SETFL, flags|O_NONBLOCK, result, errno, strerror(errno));
#endif
	
	
	
	memset(&destaddr,  0x00, sizeof(struct sockaddr_in));
	destaddr.sin_family = AF_INET;
	destaddr.sin_addr.s_addr = inet_addr(argv[1]);
	destaddr.sin_port = htons(atoi(argv[2]));
	
	
	
	result=connect(osock, (struct sockaddr *)&destaddr, sizeof(struct sockaddr_in));
	if (result>=0) { printf("%s: result=connect(osock, (struct sockaddr *)&destaddr, sizeof(struct sockaddr_in)): result=%d if (result>=0): Successful connect().\n", self, result); }
	else           { printf("%s: result=connect(osock, (struct sockaddr *)&destaddr, sizeof(struct sockaddr_in)): result=%d if (result>=0): else: Unable to connect(), Reason: %d:%s\n", self, result, errno, strerror(errno)); }
	
	
	
	tmoutrecv=10;
	strtvconn.tv_sec  = (int)tmoutrecv;
	strtvconn.tv_usec = (int)( 1E6*(tmoutrecv-(double)strtvconn.tv_sec) );
	
	FD_ZERO(&fdsrd);
	FD_ZERO(&fdswr);
	FD_SET(osock, &fdsrd);
	FD_SET(osock, &fdswr);
	result=select(osock+1, &fdsrd, &fdswr, NULL, &strtvconn);
	if (result==0) { printf("%s: result=select(osock+1, &fdsrd, &fdswr, NULL, &strtvconn): result=%d if (result==0) return RES_TIMEOUT;\n", self, result); }
	if (result <0) { printf("%s: result=select(osock+1, &fdsrd, &fdswr, NULL, &strtvconn): result=%d if (result <0) return RES_SOCKERROR;\n", self, result); }
	
	
	
	argsize=sizeof(int);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	result=getsockopt(osock,SOL_SOCKET,SO_ERROR,(char*)&flags,&argsize);
#else
	result=getsockopt(osock,SOL_SOCKET,SO_ERROR,       &flags,&argsize);
#endif
	if (result>=0) printf("%s: result=getsockopt(osock=%d,SOL_SOCKET=%d,SO_ERROR=%d,&flags=%d,&argsize=%d): result=%d if (osock>=0): Successful getsockopt(). flags=%d:%s\n", self, osock, SOL_SOCKET, SO_ERROR, flags, argsize, result, flags, strerror(flags));
	else           printf("%s: result=getsockopt(osock=%d,SOL_SOCKET=%d,SO_ERROR=%d,&flags=%d,&argsize=%d): result=%d if (osock>=0): else: Unable to getsockopt(), Reason: %d:%s\n", self, osock, SOL_SOCKET, SO_ERROR, flags, argsize, result, errno, strerror(errno));
	
	
	
	argsize=sizeof(int);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	/*iMode=0;*/
	/*flags=ioctlsocket(osock,FIONBIO,&iMode);*/
#else
	flags = fcntl(osock,F_GETFL,0);
	printf("%s: flags = fcntl(osock=%d,F_GETFL=%d,0): flags=%d\n", self, osock, F_GETFL, flags);
#endif
	
	
	
	argsize=sizeof(int);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	result=getsockopt(osock,SOL_SOCKET,SO_SNDBUF,(char*)&flags,&argsize);
#else
	result=getsockopt(osock,SOL_SOCKET,SO_SNDBUF,       &flags,&argsize);
#endif
	if (result>=0) printf("%s: result=getsockopt(osock=%d,SOL_SOCKET=%d,SO_SNDBUF=%d,&flags=%d,&argsize=%d): result=%d if (osock>=0): Successful getsockopt().\n", self, osock, SOL_SOCKET, SO_SNDBUF, flags, argsize, result);
	else           printf("%s: result=getsockopt(osock=%d,SOL_SOCKET=%d,SO_SNDBUF=%d,&flags=%d,&argsize=%d): result=%d if (osock>=0): else: Unable to getsockopt(), Reason: %d:%s\n", self, osock, SOL_SOCKET, SO_SNDBUF, flags, argsize, result, errno, strerror(errno));
	
	
	
	argsize=sizeof(int);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	result=getsockopt(osock,SOL_SOCKET,SO_RCVBUF,(char*)&flags,&argsize);
#else
	result=getsockopt(osock,SOL_SOCKET,SO_RCVBUF,       &flags,&argsize);
#endif
	if (result>=0) printf("%s: result=getsockopt(osock=%d,SOL_SOCKET=%d,SO_RCVBUF=%d,&flags=%d,&argsize=%d): result=%d if (osock>=0): Successful getsockopt().\n", self, osock, SOL_SOCKET, SO_RCVBUF, flags, argsize, result);
	else           printf("%s: result=getsockopt(osock=%d,SOL_SOCKET=%d,SO_RCVBUF=%d,&flags=%d,&argsize=%d): result=%d if (osock>=0): else: Unable to getsockopt(), Reason: %d:%s\n", self, osock, SOL_SOCKET, SO_RCVBUF, flags, argsize, result, errno, strerror(errno));
	
	
	
	argsize=sizeof(int);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	result=getsockopt(osock,SOL_SOCKET,SO_REUSEADDR,(char*)&flags,&argsize);
#else
	result=getsockopt(osock,SOL_SOCKET,SO_REUSEADDR,       &flags,&argsize);
#endif
	if (result>=0) printf("%s: result=getsockopt(osock=%d,SOL_SOCKET=%d,SO_REUSEADDR=%d,&flags=%d,&argsize=%d): result=%d if (osock>=0): Successful getsockopt().\n", self, osock, SOL_SOCKET, SO_REUSEADDR, flags, argsize, result);
	else           printf("%s: result=getsockopt(osock=%d,SOL_SOCKET=%d,SO_REUSEADDR=%d,&flags=%d,&argsize=%d): result=%d if (osock>=0): else: Unable to getsockopt(), Reason: %d:%s\n", self, osock, SOL_SOCKET, SO_REUSEADDR, flags, argsize, result, errno, strerror(errno));
	
	
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	result=getsockopt(osock,SOL_SOCKET,SO_BROADCAST,(char*)&flags,&argsize);
#else
	result=getsockopt(osock,SOL_SOCKET,SO_BROADCAST,       &flags,&argsize);
#endif
	if (result>=0) printf("%s: result=getsockopt(osock=%d,SOL_SOCKET=%d,SO_BROADCAST=%d,&flags=%d,&argsize=%d): result=%d if (osock>=0): Successful getsockopt().\n", self, osock, SOL_SOCKET, SO_BROADCAST, flags, argsize, result);
	else           printf("%s: result=getsockopt(osock=%d,SOL_SOCKET=%d,SO_BROADCAST=%d,&flags=%d,&argsize=%d): result=%d if (osock>=0): else: Unable to getsockopt(), Reason: %d:%s\n", self, osock, SO_BROADCAST, SO_ERROR, flags, argsize, result, errno, strerror(errno));
	
	
	
	argsize=sizeof(struct linger);
	memset(&soling, 0x00, sizeof(struct linger));
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	result=getsockopt(osock,SOL_SOCKET,SO_LINGER,(char*)&soling,&argsize);
#else
	result=getsockopt(osock,SOL_SOCKET,SO_LINGER,       &soling,&argsize);
#endif
	if (result>=0) printf("%s: result=getsockopt(osock=%d,SOL_SOCKET=%d,SO_LINGER=%d,&soling={l_onoff=%d,l_linger=%d},&argsize=%d): result=%d if (osock>=0): Successful getsockopt().\n", self, osock, SOL_SOCKET, SO_LINGER, soling.l_onoff, soling.l_linger, argsize, result);
	else           printf("%s: result=getsockopt(osock=%d,SOL_SOCKET=%d,SO_LINGER=%d,&soling={l_onoff=%d,l_linger=%d},&argsize=%d): result=%d if (osock>=0): else: Unable to getsockopt(), Reason: %d:%s\n", self, osock, SOL_SOCKET, SO_LINGER, soling.l_onoff, soling.l_linger, argsize, result, errno, strerror(errno));
	
	
	
	argsize=sizeof(int);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	result=getsockopt(osock,IPPROTO_TCP,TCP_NODELAY,(char*)&flags,&argsize);
#else
	result=getsockopt(osock,IPPROTO_TCP,TCP_NODELAY,       &flags,&argsize);
#endif
	if (result>=0) printf("%s: result=getsockopt(osock=%d,IPPROTO_TCP=%d,TCP_NODELAY=%d,&flags=%d,&argsize=%d): result=%d if (osock>=0): Successful getsockopt().\n", self, osock, IPPROTO_TCP, TCP_NODELAY, flags, argsize, result);
	else           printf("%s: result=getsockopt(osock=%d,IPPROTO_TCP=%d,TCP_NODELAY=%d,&flags=%d,&argsize=%d): result=%d if (osock>=0): else: Unable to getsockopt(), Reason: %d:%s\n", self, osock, IPPROTO_TCP, TCP_NODELAY, flags, argsize, result, errno, strerror(errno));
	
	
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
#else
	argsize=sizeof(int);
	result=getsockopt(osock,IPPROTO_IP,IP_DF,          &flags,&argsize);
	if (result>=0) printf("%s: result=getsockopt(osock=%d,IPPROTO_IP=%d,IP_DF=%d,&flags=%d,&argsize=%d): result=%d if (osock>=0): Successful getsockopt().\n", self, osock, IPPROTO_IP, IP_DF, flags, argsize, result);
	else           printf("%s: result=getsockopt(osock=%d,IPPROTO_IP=%d,IP_DF=%d,&flags=%d,&argsize=%d): result=%d if (osock>=0): else: Unable to getsockopt(), Reason: %d:%s\n", self, osock, IPPROTO_IP, IP_DF, flags, argsize, result, 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/sockets/getsockopt

program wyświetli informacje o sposobie uruchamiania programu:

Usage: /home/local/code/ansiccode/sockets/getsockopt <tcp:ipaddr> <tcp:ipport>
Examples:
       /home/local/code/ansiccode/sockets/getsockopt 127.0.0.1 22
       /home/local/code/ansiccode/sockets/getsockopt 127.0.0.1 80
       /home/local/code/ansiccode/sockets/getsockopt 127.0.0.1 1234

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

/home/local/code/ansiccode/sockets/getsockopt 127.0.0.1 22
/home/local/code/ansiccode/sockets/getsockopt 127.0.0.1 80
/home/local/code/ansiccode/sockets/getsockopt 127.0.0.1 1234

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

getsockopt: osock=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP): osock=3 if (osock>=0): Successful socket().
getsockopt: result=fcntl(osock=3,F_SETFL=4,flags|O_NONBLOCK=2050): result=0 if (osock>=0): Successful getsockopt().
getsockopt: result=connect(osock, (struct sockaddr *)&destaddr, sizeof(struct sockaddr_in)): result=-1 if (result>=0): else: Unable to connect(), Reason: 115:Operation now in progress
getsockopt: result=getsockopt(osock=3,SOL_SOCKET=1,SO_ERROR=4,&flags=0,&argsize=4): result=0 if (osock>=0): Successful getsockopt(). flags=0:Success
getsockopt: flags = fcntl(osock=3,F_GETFL=3,0): flags=2050
getsockopt: result=getsockopt(osock=3,SOL_SOCKET=1,SO_SNDBUF=7,&flags=50424,&argsize=4): result=0 if (osock>=0): Successful getsockopt().
getsockopt: result=getsockopt(osock=3,SOL_SOCKET=1,SO_RCVBUF=8,&flags=87664,&argsize=4): result=0 if (osock>=0): Successful getsockopt().
getsockopt: result=getsockopt(osock=3,SOL_SOCKET=1,SO_REUSEADDR=2,&flags=0,&argsize=4): result=0 if (osock>=0): Successful getsockopt().
getsockopt: result=getsockopt(osock=3,SOL_SOCKET=1,SO_BROADCAST=6,&flags=0,&argsize=4): result=0 if (osock>=0): Successful getsockopt().
getsockopt: result=getsockopt(osock=3,SOL_SOCKET=1,SO_LINGER=13,&soling={l_onoff=0,l_linger=0},&argsize=8): result=0 if (osock>=0): Successful getsockopt().
getsockopt: result=getsockopt(osock=3,IPPROTO_TCP=6,TCP_NODELAY=1,&flags=0,&argsize=4): result=0 if (osock>=0): Successful getsockopt().
getsockopt: result=getsockopt(osock=3,IPPROTO_IP=0,IP_DF=16384,&flags=0,&argsize=4): result=-1 if (osock>=0): else: Unable to getsockopt(), Reason: 92:Protocol not available

getsockopt: osock=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP): osock=3 if (osock>=0): Successful socket().
getsockopt: result=fcntl(osock=3,F_SETFL=4,flags|O_NONBLOCK=2050): result=0 if (osock>=0): Successful getsockopt().
getsockopt: result=connect(osock, (struct sockaddr *)&destaddr, sizeof(struct sockaddr_in)): result=-1 if (result>=0): else: Unable to connect(), Reason: 115:Operation now in progress
getsockopt: result=getsockopt(osock=3,SOL_SOCKET=1,SO_ERROR=4,&flags=0,&argsize=4): result=0 if (osock>=0): Successful getsockopt(). flags=0:Success
getsockopt: flags = fcntl(osock=3,F_GETFL=3,0): flags=2050
getsockopt: result=getsockopt(osock=3,SOL_SOCKET=1,SO_SNDBUF=7,&flags=50424,&argsize=4): result=0 if (osock>=0): Successful getsockopt().
getsockopt: result=getsockopt(osock=3,SOL_SOCKET=1,SO_RCVBUF=8,&flags=87664,&argsize=4): result=0 if (osock>=0): Successful getsockopt().
getsockopt: result=getsockopt(osock=3,SOL_SOCKET=1,SO_REUSEADDR=2,&flags=0,&argsize=4): result=0 if (osock>=0): Successful getsockopt().
getsockopt: result=getsockopt(osock=3,SOL_SOCKET=1,SO_BROADCAST=6,&flags=0,&argsize=4): result=0 if (osock>=0): Successful getsockopt().
getsockopt: result=getsockopt(osock=3,SOL_SOCKET=1,SO_LINGER=13,&soling={l_onoff=0,l_linger=0},&argsize=8): result=0 if (osock>=0): Successful getsockopt().
getsockopt: result=getsockopt(osock=3,IPPROTO_TCP=6,TCP_NODELAY=1,&flags=0,&argsize=4): result=0 if (osock>=0): Successful getsockopt().
getsockopt: result=getsockopt(osock=3,IPPROTO_IP=0,IP_DF=16384,&flags=0,&argsize=4): result=-1 if (osock>=0): else: Unable to getsockopt(), Reason: 92:Protocol not available

getsockopt: osock=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP): osock=3 if (osock>=0): Successful socket().
getsockopt: result=fcntl(osock=3,F_SETFL=4,flags|O_NONBLOCK=2050): result=0 if (osock>=0): Successful getsockopt().
getsockopt: result=connect(osock, (struct sockaddr *)&destaddr, sizeof(struct sockaddr_in)): result=-1 if (result>=0): else: Unable to connect(), Reason: 115:Operation now in progress
getsockopt: result=getsockopt(osock=3,SOL_SOCKET=1,SO_ERROR=4,&flags=111,&argsize=4): result=0 if (osock>=0): Successful getsockopt(). flags=111:Connection refused
getsockopt: flags = fcntl(osock=3,F_GETFL=3,0): flags=2050
getsockopt: result=getsockopt(osock=3,SOL_SOCKET=1,SO_SNDBUF=7,&flags=16384,&argsize=4): result=0 if (osock>=0): Successful getsockopt().
getsockopt: result=getsockopt(osock=3,SOL_SOCKET=1,SO_RCVBUF=8,&flags=87380,&argsize=4): result=0 if (osock>=0): Successful getsockopt().
getsockopt: result=getsockopt(osock=3,SOL_SOCKET=1,SO_REUSEADDR=2,&flags=0,&argsize=4): result=0 if (osock>=0): Successful getsockopt().
getsockopt: result=getsockopt(osock=3,SOL_SOCKET=1,SO_BROADCAST=6,&flags=0,&argsize=4): result=0 if (osock>=0): Successful getsockopt().
getsockopt: result=getsockopt(osock=3,SOL_SOCKET=1,SO_LINGER=13,&soling={l_onoff=0,l_linger=0},&argsize=8): result=0 if (osock>=0): Successful getsockopt().
getsockopt: result=getsockopt(osock=3,IPPROTO_TCP=6,TCP_NODELAY=1,&flags=0,&argsize=4): result=0 if (osock>=0): Successful getsockopt().
getsockopt: result=getsockopt(osock=3,IPPROTO_IP=0,IP_DF=16384,&flags=0,&argsize=4): result=-1 if (osock>=0): else: Unable to getsockopt(), Reason: 92:Protocol not available

#top listen¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | beej.us | gnu.org

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

/* Prepare to accept connections on socket FD.
   N connection requests will be queued before further requests are refused.
   Returns 0 on success, -1 for errors.  */
extern int listen (int __fd, int __n) __THROW;

Powiązane:
accept(), bind(), listen(),

Opis:

Funkcja listen()

Argumenty:
int __fd -
int __n -

Zwracana wartość:
int -

Example:
zawartość pliku listen.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, */

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
  #define WIN32_LEAN_AND_MEAN
  #include <winsock.h>     /* for SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, AF_INET, PF_INET, socket(), connect(), send(), recv(), sendto(), recvfrom(), shutdown(), */
                           /* for bind(), listen(), accept(), getsockname(), getsockopt(), setsockopt(), */
                           /* for in_addr_t, INADDR_ANY, INADDR_NONE, INADDR_BROADCAST, IPPROTO_TCP, IPPROTO_UDP, IPPROTO_ICMP, IPPROTO_RAW, */
                           /* for struct sockaddr_in, struct in_addr, inet_addr(), struct hostent, gethostbyname(), gethostbyaddr(), */
#else
  #include <sys/socket.h>  /* for bits/socket.h, SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, SOCK_PACKET, AF_UNIX, PF_UNIX, AF_FILE, PF_FILE, AF_INET, PF_INET, MSG_OOB, MSG_PEEK, MSG_DONTWAIT, struct msghdr, struct sockaddr, struct osockaddr, */
                           /* for socket(), bind(), getsockname(), connect(), getpeername(), send(), recv(), sendto(), recvfrom(), sendmsg(), recvmsg(), getsockopt(), setsockopt(), listen(), accept(), shutdown(), sockatmark(), */
  #include <sys/un.h>      /* for struct sockaddr_un, */
  #include <arpa/inet.h>   /* for netinet/in.h, in_addr_t, INADDR_ANY, INADDR_NONE, INADDR_BROADCAST, IPPROTO_TCP, IPPROTO_UDP, IPPROTO_ICMP, IPPROTO_RAW, */
                           /* for struct sockaddr_in, struct in_addr, inet_addr(), inet_ntoa(), inet_pton(), inet_ntop(), inet_aton(), inet_neta(), inet_net_ntop(), inet_net_pton(), */
  #include <netinet/in.h>  /* need in OpenBSD, for in_port_t, in_addr_t, struct in_addr, struct in6_addr, struct sockaddr_in, struct sockaddr_in6, ntohl(), ntohs(), htonl(), htons(), */
  #include <netinet/in_systm.h> /* need in OpenBSD for - typedef u_int32_t n_time - used in netinet/ip.h */
#endif

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
/* C:/Dev-CPP/bin/../lib/gcc/mingw32/3.4.2/../../../../include/winsock.h:32: */
/*typedef u_int SOCKET;*/
#else
typedef int SOCKET;
#endif

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
/* Sleep - Capital first letter */
/* #include <windows.h> + #include <winbase.h> +++ -lws2_32 */
#define sleep(time) Sleep(1000*time)
#define usleep(useconds) Sleep((useconds+999) / 1000)
#endif



int main(int argc, char **argv) {
	char *self;
	SOCKET osockaftcp;
	SOCKET osockafudp;
	SOCKET osockafunix;
	
	struct sockaddr_in tcpaddr;
	struct sockaddr_in udpaddr;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
#else
	struct sockaddr_un unixaddr;
#endif
	
	int maxqueue;
	int result;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<7) {
		printf("Usage: %s <tcp:ipaddr> <tcp:ipport> <udp:ipaddr> <udp:ipport> <unix:/path/to/socket> <max-queue>\n", argv[0]);
		return 0;
	}
	
	
	
	osockaftcp=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockaftcp!=INVALID_SOCKET)
#else
	if (osockaftcp>=0)
#endif
	                   printf("%s: osockaftcp=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP): osockaftcp=%d if (osock>=0): Successful socket().\n", self, osockaftcp);
	else               printf("%s: osockaftcp=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP): osockaftcp=%d if (osock>=0): else: Unable to socket(), Reason: %d:%s\n", self, osockaftcp, errno, strerror(errno));
	
	
	osockafudp=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockafudp!=INVALID_SOCKET)
#else
	if (osockafudp>=0)
#endif
	                   printf("%s: osockafudp=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP): osockafudp=%d if (osockafudp>=0): Successful socket().\n", self, osockafudp);
	else               printf("%s: osockafudp=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP): osockafudp=%d if (osockafudp>=0): else: Unable to socket(), Reason: %d:%s\n", self, osockafudp, errno, strerror(errno));
	
	
	osockafunix=socket(AF_UNIX, SOCK_STREAM, 0);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockafunix!=INVALID_SOCKET)
#else
	if (osockafunix>=0)
#endif
	                    printf("%s: osockafunix=socket(AF_UNIX, SOCK_STREAM, 0): osockafunix=%d if (osockafunix>=0): Successful socket().\n", self, osockafunix);
	else                printf("%s: osockafunix=socket(AF_UNIX, SOCK_STREAM, 0): osockafunix=%d if (osockafunix>=0): else: Unable to socket(), Reason: %d:%s\n", self, osockafunix, errno, strerror(errno));
	
	
	
	memset(&tcpaddr,  0x00, sizeof(struct sockaddr_in));
	memset(&udpaddr,  0x00, sizeof(struct sockaddr_in));
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
#else
	memset(&unixaddr, 0x00, sizeof(struct sockaddr_un));
#endif
	
	
	tcpaddr.sin_family = AF_INET;
	if (strncmp(argv[1],"0.0.0.0",7)==0) tcpaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	else                                 tcpaddr.sin_addr.s_addr = inet_addr(argv[1]);
	tcpaddr.sin_port = htons(atoi(argv[2]));
	
	
	udpaddr.sin_family = AF_INET;
	if (strncmp(argv[3],"0.0.0.0",7)==0) udpaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	else                                 udpaddr.sin_addr.s_addr = inet_addr(argv[3]);
	udpaddr.sin_port = htons(atoi(argv[4]));
	
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
#else
	unixaddr.sun_family = AF_UNIX;
	strncpy(unixaddr.sun_path, argv[5], sizeof(unixaddr.sun_path));
#endif
	
	
	
	result=bind(osockaftcp, (struct sockaddr*)&tcpaddr, sizeof(struct sockaddr_in));
	if (result>=0) printf("%s: result=bind(osockaftcp, (struct sockaddr*)&tcpaddr, sizeof(struct sockaddr_in)): result=%d if (result>=0): Successful bind().\n", self, result);
	else           printf("%s: result=bind(osockaftcp, (struct sockaddr*)&tcpaddr, sizeof(struct sockaddr_in)): result=%d if (result>=0): else: Unable to bind(), Reason: %d:%s\n", self, result, errno, strerror(errno));
	
	
	result=bind(osockafudp, (struct sockaddr*)&udpaddr, sizeof(struct sockaddr_in));
	if (result>=0) printf("%s: result=bind(osockafudp, (struct sockaddr*)&udpaddr, sizeof(struct sockaddr_in)): result=%d if (result>=0): Successful bind().\n", self, result);
	else           printf("%s: result=bind(osockafudp, (struct sockaddr*)&udpaddr, sizeof(struct sockaddr_in)): result=%d if (result>=0): else: Unable to bind(), Reason: %d:%s\n", self, result, errno, strerror(errno));
	
	/** @name Unable to listen socket, Reason: 98:Address already in use */
	/** (NOTICE: FIX: remove socket if exists) (TODO: check if it is still using !!!) */
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
#else
	if (access(unixaddr.sun_path,F_OK)==0) { printf("%s: if (access(unixaddr.sun_path,F_OK)==0): previous socket exists: unlink(unixaddr.sun_path=%s)\n", self, unixaddr.sun_path); unlink(unixaddr.sun_path); }
	result=bind(osockafunix, (struct sockaddr*)&unixaddr, sizeof(unixaddr.sun_family)+strlen(unixaddr.sun_path));
	if (result>=0) printf("%s: result=bind(osockafunix, (struct sockaddr*)&unixaddr, sizeof(unixaddr.sun_family)+strlen(unixaddr.sun_path)): result=%d if (result>=0): Successful bind().\n", self, result);
	else           printf("%s: result=bind(osockafunix, (struct sockaddr*)&unixaddr, sizeof(unixaddr.sun_family)+strlen(unixaddr.sun_path)): result=%d if (result>=0): else: Unable to bind(), Reason: %d:%s\n", self, result, errno, strerror(errno));
#endif
	
	
	
	maxqueue=atoi(argv[6]);
	
	result=listen(osockaftcp, maxqueue);
	if (result>=0) printf("%s: result=listen(osockaftcp, maxqueue): result=%d if (result>=0): Successful listen().\n", self, result);
	else           printf("%s: result=listen(osockaftcp, maxqueue): result=%d if (result>=0): else: Unable to listen(), Reason: %d:%s\n", self, result, errno, strerror(errno));
	
	
	/** @name UDP: listen+accept not suppoted: socket+bind:recvfrom+sendto */
	result=listen(osockafudp, maxqueue);
	if (result>=0) printf("%s: result=listen(osockafudp, maxqueue): result=%d if (result>=0): Successful listen socket.\n", self, result);
	else           printf("%s: result=listen(osockafudp, maxqueue): result=%d if (result>=0): else: Unable to listen socket, Reason: %d:%s\n", self, result, errno, strerror(errno));
	
	
	result=listen(osockafunix, maxqueue);
	if (result>=0) printf("%s: result=listen(osockafunix, maxqueue): result=%d if (result>=0): Successful listen().\n", self, result);
	else           printf("%s: result=listen(osockafunix, maxqueue): result=%d if (result>=0): else: Unable to listen(), Reason: %d:%s\n", self, result, errno, strerror(errno));
	
	
	
	sleep(30);
	
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockaftcp!=INVALID_SOCKET) close(osockaftcp);
#else
	if (osockaftcp>=0) close(osockaftcp);
#endif
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockafudp!=INVALID_SOCKET) close(osockafudp);
#else
	if (osockafudp>=0) close(osockafudp);
#endif
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockafunix!=INVALID_SOCKET) close(osockafunix);
#else
	if (osockafunix>=0) close(osockafunix);
#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/sockets/listen

program wyświetli informacje o sposobie uruchamiania programu:

Usage: /home/local/code/ansiccode/sockets/listen <tcp:ipaddr> <tcp:ipport> <udp:ipaddr> <udp:ipport> <unix:/path/to/socket> <max-queue>

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

/home/local/code/ansiccode/sockets/listen 0.0.0.0 2222 0.0.0.0 2222 /home/local/code/ansiccode/sockets/listen.sock 5

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

listen: osockaftcp=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP): osockaftcp=3 if (osock>=0): Successful socket().
listen: osockafudp=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP): osockafudp=4 if (osockafudp>=0): Successful socket().
listen: osockafunix=socket(AF_UNIX, SOCK_STREAM, 0): osockafunix=5 if (osockafunix>=0): Successful socket().
listen: result=bind(osockaftcp, (struct sockaddr*)&tcpaddr, sizeof(struct sockaddr_in)): result=0 if (result>=0): Successful bind().
listen: result=bind(osockafudp, (struct sockaddr*)&udpaddr, sizeof(struct sockaddr_in)): result=0 if (result>=0): Successful bind().
listen: result=bind(osockafunix, (struct sockaddr*)&unixaddr, sizeof(unixaddr.sun_family)+strlen(unixaddr.sun_path)): result=0 if (result>=0): Successful bind().
listen: result=listen(osockaftcp, maxqueue): result=0 if (result>=0): Successful listen().
listen: result=listen(osockafudp, maxqueue): result=-1 if (result>=0): else: Unable to listen socket, Reason: 95:Operation not supported
listen: result=listen(osockafunix, maxqueue): result=0 if (result>=0): Successful listen().

#top poll¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | beej.us | gnu.org

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

/* Poll the file descriptors described by the NFDS structures starting at
   FDS.  If TIMEOUT is nonzero and not -1, allow TIMEOUT milliseconds for
   an event to occur; if TIMEOUT is -1, block until an event occurs.
   Returns the number of file descriptors with events, zero if timed out,
   or -1 for errors.

   This function is a cancellation point and therefore not marked with
   __THROW.  */
extern int poll (struct pollfd *__fds, nfds_t __nfds, int __timeout);

Powiązane:
connect(), poll(), recv(), select(), send(), shutdown(),

Opis:

Funkcja poll()

Argumenty:
struct pollfd *__fds -
nfds_t __nfds -
int __timeout -

Zwracana wartość:
int -

Example:
zawartość pliku poll.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/sockets/poll

program wyświetli informacje o sposobie uruchamiania programu:

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

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

#top recv¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | beej.us | gnu.org

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

/* Read N bytes into BUF from socket FD.
   Returns the number read or -1 for errors.

   This function is a cancellation point and therefore not marked with
   __THROW.  */
extern ssize_t recv (int __fd, void *__buf, size_t __n, int __flags);

Powiązane:
connect(), poll(), recv(), select(), send(), shutdown(),

Opis:

Funkcja recv()

Argumenty:
int __fd -
void *__buf -
size_t __n -
int __flags -

Zwracana wartość:
ssize_t -
-1 + errno = EAGAIN (Resource temporarily unavailable)
-1 + errno = EHOSTUNREACH (No route to host)

#top recvfrom¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | beej.us | gnu.org

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

/* Read N bytes into BUF through socket FD.
   If ADDR is not NULL, fill in *ADDR_LEN bytes of it with tha address of
   the sender, and store the actual size of the address in *ADDR_LEN.
   Returns the number of bytes read or -1 for errors.

   This function is a cancellation point and therefore not marked with
   __THROW.  */
extern ssize_t recvfrom (int __fd, void *__restrict __buf, size_t __n,
             int __flags, __SOCKADDR_ARG __addr,
             socklen_t *__restrict __addr_len);

Powiązane:
recvfrom(), recvmsg(), sendmsg(), sendto(),

Opis:

Funkcja recvfrom()

Argumenty:
int __fd -
void *__restrict __buf -
size_t __n -
int __flags -
__SOCKADDR_ARG __addr, -
socklen_t *__restrict __addr_len -

Zwracana wartość:
ssize_t -

Example:
zawartość pliku recvfrom.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, */

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
  #define WIN32_LEAN_AND_MEAN
  #include <winsock.h>     /* for SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, AF_INET, PF_INET, socket(), connect(), send(), recv(), sendto(), recvfrom(), shutdown(), */
                           /* for bind(), listen(), accept(), getsockname(), getsockopt(), setsockopt(), */
                           /* for in_addr_t, INADDR_ANY, INADDR_NONE, INADDR_BROADCAST, IPPROTO_TCP, IPPROTO_UDP, IPPROTO_ICMP, IPPROTO_RAW, */
                           /* for struct sockaddr_in, struct in_addr, inet_addr(), struct hostent, gethostbyname(), gethostbyaddr(), */
#else
  #include <sys/socket.h>  /* for bits/socket.h, SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, SOCK_PACKET, AF_UNIX, PF_UNIX, AF_FILE, PF_FILE, AF_INET, PF_INET, MSG_OOB, MSG_PEEK, MSG_DONTWAIT, struct msghdr, struct sockaddr, struct osockaddr, */
                           /* for socket(), bind(), getsockname(), connect(), getpeername(), send(), recv(), sendto(), recvfrom(), sendmsg(), recvmsg(), getsockopt(), setsockopt(), listen(), accept(), shutdown(), sockatmark(), */
  #include <sys/un.h>      /* for struct sockaddr_un, */
  #include <arpa/inet.h>   /* for netinet/in.h, in_addr_t, INADDR_ANY, INADDR_NONE, INADDR_BROADCAST, IPPROTO_TCP, IPPROTO_UDP, IPPROTO_ICMP, IPPROTO_RAW, */
                           /* for struct sockaddr_in, struct in_addr, inet_addr(), inet_ntoa(), inet_pton(), inet_ntop(), inet_aton(), inet_neta(), inet_net_ntop(), inet_net_pton(), */
  #include <netinet/in.h>  /* need in OpenBSD, for in_port_t, in_addr_t, struct in_addr, struct in6_addr, struct sockaddr_in, struct sockaddr_in6, ntohl(), ntohs(), htonl(), htons(), */
  #include <netinet/in_systm.h> /* need in OpenBSD for - typedef u_int32_t n_time - used in netinet/ip.h */
#endif

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
/* C:/Dev-CPP/bin/../lib/gcc/mingw32/3.4.2/../../../../include/winsock.h:32: */
/*typedef u_int SOCKET;*/
#else
typedef int SOCKET;
#endif



/*
The only real difference is in the API and the functionality...
You can implement the functionality of sendto() using sendmsg(),
but sendmsg() also lets you do lots of other nifty stuff you can't do via sendto()...
Eg: send control/ancillary messages, or send multiple seperate
chunks of data in a single operation (via iovec scatter/gather
arrays)...  Basically, sendmsg() is the ultimate low-level socket
sending function, and really the only one that a system actually
need implement, since the rest can all be built on top of it easily...
*/



int main(int argc, char **argv) {
	char *self;
	SOCKET lsock;
	struct sockaddr_in listaddr;
	struct sockaddr_in fromaddr;
	char ipaddr[16+1+5+1];
	int  iaport;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	int addrsize;
#else
	unsigned int addrsize;
#endif
	char buffdata[16384];
	int result;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<3) {
		printf("Usage: %s <udp:ipaddr> <udp:ipport>\n", argv[0]);
		return 0;
	}
	
	lsock=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (lsock!=INVALID_SOCKET)
#else
	if (lsock>=0)
#endif
	                   printf("%s: lsock=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP): lsock=%d if (osock>=0): Successful socket().\n", self, lsock);
	else               printf("%s: lsock=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP): lsock=%d if (osock>=0): else: Unable to socket(), Reason: %d:%s\n", self, lsock, errno, strerror(errno));
	
	
	
	memset(&listaddr,  0x00, sizeof(struct sockaddr_in));
	listaddr.sin_family = AF_INET;
	if (strncmp(argv[1],"0.0.0.0",7)==0) listaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	else                                 listaddr.sin_addr.s_addr = inet_addr(argv[1]);
	listaddr.sin_port = htons(atoi(argv[2]));
	
	
	
	memset(ipaddr, 0x00, sizeof(ipaddr));
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	snprintf(ipaddr, sizeof(ipaddr), "%d.%d.%d.%d", (unsigned int)(fromaddr.sin_addr.s_addr&0x000000FF), (unsigned int)(fromaddr.sin_addr.s_addr&0x0000FF00)>>8, (unsigned int)(fromaddr.sin_addr.s_addr&0x00FF0000)>>16, (unsigned int)(fromaddr.sin_addr.s_addr&0xFF000000)>>24);
#else
	inet_ntop(AF_INET, &fromaddr.sin_addr, ipaddr, sizeof(ipaddr));
#endif
	iaport=ntohs(fromaddr.sin_port);
	
	result=bind(lsock, (struct sockaddr*)&listaddr, sizeof(struct sockaddr_in));
	if (result>=0) printf("%s: result=bind(lsock=%d, (struct sockaddr*)&listaddr=%s:%d, sizeof(struct sockaddr_in)): result=%d if (result>=0): Successful bind() socket.\n", self, lsock, ipaddr, iaport, result);
	else           printf("%s: result=bind(lsock=%d, (struct sockaddr*)&listaddr=%s:%d, sizeof(struct sockaddr_in)): result=%d if (result>=0): else: Unable to bind() socket, Reason: %d:%s\n", self, lsock, ipaddr, iaport, result, errno, strerror(errno));
	if (result <0) { close(lsock); return 1; }
	
	
	
	/** @name UDP: listen+accept not suppoted: socket+bind:recvfrom+sendto */
	/*result=listen(osock, maxqueue);*/
	/*if (result>=0) printf("%s: result=listen(osock, maxqueue): result=%d if (result>=0): Successful listen socket.\n", self, result);*/
	/*else           printf("%s: result=listen(osock, maxqueue): result=%d if (result>=0): else: Unable to listen socket, Reason: %d:%s\n", self, result, errno, strerror(errno));*/
	
	
	
	while (1) {
		memset(buffdata, 0x00, sizeof(buffdata));
		addrsize=sizeof(struct sockaddr_in);
		result=recvfrom(lsock, buffdata, sizeof(buffdata), 0, (struct sockaddr*)&fromaddr, &addrsize);
		
		memset(ipaddr, 0x00, sizeof(ipaddr));
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
		snprintf(ipaddr, sizeof(ipaddr), "%d.%d.%d.%d", (unsigned int)(fromaddr.sin_addr.s_addr&0x000000FF), (unsigned int)(fromaddr.sin_addr.s_addr&0x0000FF00)>>8, (unsigned int)(fromaddr.sin_addr.s_addr&0x00FF0000)>>16, (unsigned int)(fromaddr.sin_addr.s_addr&0xFF000000)>>24);
#else
		inet_ntop(AF_INET, &fromaddr.sin_addr, ipaddr, sizeof(ipaddr));
#endif
		iaport=ntohs(fromaddr.sin_port);
		
		if (result>=0) printf("%s: result=recvfrom(lsock=%d, buffdata, sizeof(buffdata)=%u, 0, (struct sockaddr*)&fromaddr=%s:%d, &addrsize=%d): result=%d if (result>=0): Successful recvfrom().\n", self, lsock, sizeof(buffdata), ipaddr, iaport, addrsize, result);
		else           printf("%s: result=recvfrom(lsock=%d, buffdata, sizeof(buffdata)=%u, 0, (struct sockaddr*)&fromaddr=%s:%d, &addrsize=%d): result=%d if (result>=0): else: Unable to recvfrom(), Reason: %d:%s\n", self, lsock, sizeof(buffdata), ipaddr, iaport, addrsize, result, errno, strerror(errno));
		printf("%s: strlen(buffdata)=%lu result=%d buffdata=|%s|\n", self, (unsigned long int)strlen(buffdata), result, buffdata);
		
		
		
		memset(ipaddr, 0x00, sizeof(ipaddr));
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
		snprintf(ipaddr, sizeof(ipaddr), "%d.%d.%d.%d", (unsigned int)(fromaddr.sin_addr.s_addr&0x000000FF), (unsigned int)(fromaddr.sin_addr.s_addr&0x0000FF00)>>8, (unsigned int)(fromaddr.sin_addr.s_addr&0x00FF0000)>>16, (unsigned int)(fromaddr.sin_addr.s_addr&0xFF000000)>>24);
#else
		inet_ntop(AF_INET, &fromaddr.sin_addr, ipaddr, sizeof(ipaddr));
#endif
		iaport=ntohs(fromaddr.sin_port);
		
		result=sendto(lsock, buffdata, strlen(buffdata), 0, (struct sockaddr*)&fromaddr, addrsize);
		if (result>=0) printf("%s: result=sendto(lsock=%d, buffdata, strlen(buffdata)=%lu, 0, (struct sockaddr*)&fromaddr=%s:%d, addrsize=%d): result=%d if (result>=0): Successful sendto().\n", self, lsock, (long unsigned int)strlen(buffdata), ipaddr, iaport, addrsize, result);
		else           printf("%s: result=sendto(lsock=%d, buffdata, strlen(buffdata)=%lu, 0, (struct sockaddr*)&fromaddr=%s:%d, addrsize=%d): result=%d if (result>=0): else: Unable to sendto(), Reason: %d:%s\n", self, lsock, (long unsigned int)strlen(buffdata), ipaddr, iaport, addrsize, result, errno, strerror(errno));
		if (result<0) { close(lsock); return 1; }
		printf("%s: strlen(buffdata)=%lu result=%d buffdata=|%s|\n", self, (unsigned long int)strlen(buffdata), result, buffdata);
	}
	
	
	
	close(lsock);
	
	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/sockets/recvfrom

program wyświetli informacje o sposobie uruchamiania programu:

Usage: /home/local/code/ansiccode/sockets/recvfrom <udp:ipaddr> <udp:ipport>

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

/home/local/code/ansiccode/sockets/recvfrom 0.0.0.0 2222

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

recvfrom: lsock=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP): lsock=3 if (osock>=0): Successful socket().
recvfrom: result=bind(lsock=3, (struct sockaddr*)&listaddr=104.22.255.191:1032, sizeof(struct sockaddr_in)): result=0 if (result>=0): Successful bind() socket.
recvfrom: result=recvfrom(lsock=3, buffdata, sizeof(buffdata)=16384, 0, (struct sockaddr*)&fromaddr=127.0.0.1:53405, &addrsize=16): result=16 if (result>=0): Successful recvfrom().
recvfrom: strlen(buffdata)=16 result=16 buffdata=|GET / HTTP/1.1
|
recvfrom: result=sendto(lsock=3, buffdata, strlen(buffdata)=16, 0, (struct sockaddr*)&fromaddr=127.0.0.1:53405, addrsize=16): result=16 if (result>=0): Successful sendto().
recvfrom: strlen(buffdata)=16 result=16 buffdata=|GET / HTTP/1.1
|

#top recvmsg¶

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

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

/* Receive a message as described by MESSAGE from socket FD.
   Returns the number of bytes read or -1 for errors.

   This function is a cancellation point and therefore not marked with
   __THROW.  */
extern ssize_t recvmsg (int __fd, struct msghdr *__message, int __flags);

Powiązane:
recvfrom(), recvmsg(), sendmsg(), sendto(),

Opis:

Funkcja recvmsg()

Argumenty:
int __fd -
struct msghdr *__message -
int __flags - MSG_ERRQUEUE

Zwracana wartość:
ssize_t -
-1 + errno = EAGAIN (Resource temporarily unavailable)

Example:
zawartość pliku recvmsg.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:

program wyświetli informacje o sposobie uruchamiania programu:

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

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

#top select¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | beej.us

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

/* Check the first NFDS descriptors each in READFDS (if not NULL) for read
   readiness, in WRITEFDS (if not NULL) for write readiness, and in EXCEPTFDS
   (if not NULL) for exceptional conditions.  If TIMEOUT is not NULL, time out
   after waiting the interval specified therein.  Returns the number of ready
   descriptors, or -1 for errors.

   This function is a cancellation point and therefore not marked with
   __THROW.  */
extern int select (int __nfds, fd_set *__restrict __readfds,
           fd_set *__restrict __writefds,
           fd_set *__restrict __exceptfds,
           struct timeval *__restrict __timeout);

Powiązane:
connect(), poll(), recv(), select(), send(), shutdown(),

Opis:

Funkcja select()

Argumenty:
int __nfds -
fd_set *__restrict __readfds -
fd_set *__restrict __writefds -
fd_set *__restrict __exceptfds -
struct timeval *__restrict __timeout -

Zwracana wartość:
int -

#top send¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | beej.us | gnu.org

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

/* Send N bytes of BUF to socket FD.  Returns the number sent or -1.

   This function is a cancellation point and therefore not marked with
   __THROW.  */
extern ssize_t send (int __fd, __const void *__buf, size_t __n, int __flags);

Powiązane:
connect(), poll(), recv(), select(), send(), shutdown(),

Opis:

Funkcja send()

Argumenty:
int __fd -
const void *__buf -
size_t __n -
int __flags -
MSG_NOSIGNAL

Zwracana wartość:
ssize_t -

#top sendmsg¶

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

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

/* Send a message described MESSAGE on socket FD.
   Returns the number of bytes sent, or -1 for errors.

   This function is a cancellation point and therefore not marked with
   __THROW.  */
extern ssize_t sendmsg (int __fd, __const struct msghdr *__message,
            int __flags);

Powiązane:
recvfrom(), recvmsg(), sendmsg(), sendto(),

Opis:

Funkcja sendmsg()

Argumenty:
int __fd -
const struct msghdr *__message -
int __flags -

Zwracana wartość:
ssize_t -

Example:
zawartość pliku sendmsg.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:

program wyświetli informacje o sposobie uruchamiania programu:

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

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

#top sendto¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | beej.us | gnu.org

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

/* Send N bytes of BUF on socket FD to peer at address ADDR (which is
   ADDR_LEN bytes long).  Returns the number sent, or -1 for errors.

   This function is a cancellation point and therefore not marked with
   __THROW.  */
extern ssize_t sendto (int __fd, __const void *__buf, size_t __n,
               int __flags, __CONST_SOCKADDR_ARG __addr,
               socklen_t __addr_len);

Powiązane:
recvfrom(), recvmsg(), sendmsg(), sendto(),

Opis:

Funkcja sendto()

Argumenty:
int __fd -
const void *__buf -
size_t __n -
int __flags -
__CONST_SOCKADDR_ARG __addr -
socklen_t __addr_len -

Zwracana wartość:
ssize_t -
-1 + errno = EMSGSIZE (Message to long)

Example:
zawartość pliku sendto.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, */

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
  #define WIN32_LEAN_AND_MEAN
  #include <winsock.h>     /* for SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, AF_INET, PF_INET, socket(), connect(), send(), recv(), sendto(), recvfrom(), shutdown(), */
                           /* for bind(), listen(), accept(), getsockname(), getsockopt(), setsockopt(), */
                           /* for in_addr_t, INADDR_ANY, INADDR_NONE, INADDR_BROADCAST, IPPROTO_TCP, IPPROTO_UDP, IPPROTO_ICMP, IPPROTO_RAW, */
                           /* for struct sockaddr_in, struct in_addr, inet_addr(), struct hostent, gethostbyname(), gethostbyaddr(), */
#else
  #include <sys/socket.h>  /* for bits/socket.h, SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, SOCK_PACKET, AF_UNIX, PF_UNIX, AF_FILE, PF_FILE, AF_INET, PF_INET, MSG_OOB, MSG_PEEK, MSG_DONTWAIT, struct msghdr, struct sockaddr, struct osockaddr, */
                           /* for socket(), bind(), getsockname(), connect(), getpeername(), send(), recv(), sendto(), recvfrom(), sendmsg(), recvmsg(), getsockopt(), setsockopt(), listen(), accept(), shutdown(), sockatmark(), */
  #include <sys/un.h>      /* for struct sockaddr_un, */
  #include <arpa/inet.h>   /* for netinet/in.h, in_addr_t, INADDR_ANY, INADDR_NONE, INADDR_BROADCAST, IPPROTO_TCP, IPPROTO_UDP, IPPROTO_ICMP, IPPROTO_RAW, */
                           /* for struct sockaddr_in, struct in_addr, inet_addr(), inet_ntoa(), inet_pton(), inet_ntop(), inet_aton(), inet_neta(), inet_net_ntop(), inet_net_pton(), */
  #include <netinet/in.h>  /* need in OpenBSD, for in_port_t, in_addr_t, struct in_addr, struct in6_addr, struct sockaddr_in, struct sockaddr_in6, ntohl(), ntohs(), htonl(), htons(), */
  #include <netinet/in_systm.h> /* need in OpenBSD for - typedef u_int32_t n_time - used in netinet/ip.h */
#endif

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
/* C:/Dev-CPP/bin/../lib/gcc/mingw32/3.4.2/../../../../include/winsock.h:32: */
/*typedef u_int SOCKET;*/
#else
typedef int SOCKET;
#endif



/*
The only real difference is in the API and the functionality...
You can implement the functionality of sendto() using sendmsg(),
but sendmsg() also lets you do lots of other nifty stuff you can't do via sendto()...
Eg: send control/ancillary messages, or send multiple seperate
chunks of data in a single operation (via iovec scatter/gather
arrays)...  Basically, sendmsg() is the ultimate low-level socket
sending function, and really the only one that a system actually
need implement, since the rest can all be built on top of it easily...
*/



int main(int argc, char **argv) {
	char *self;
	SOCKET osock;
	struct sockaddr_in totoaddr;
	char ipaddr[16+1+5+1];
	int  iaport;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	int addrsize;
#else
	unsigned int addrsize;
#endif
	char buffdata[16384];
	int result;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<3) {
		printf("Usage: %s <udp:ipaddr> <udp:ipport>\n", argv[0]);
		return 0;
	}
	
	osock=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osock!=INVALID_SOCKET)
#else
	if (osock>=0)
#endif
	                   printf("%s: osock=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP): osock=%d if (osock>=0): Successful socket().\n", self, osock);
	else               printf("%s: osock=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP): osock=%d if (osock>=0): else: Unable to socket(), Reason: %d:%s\n", self, osock, errno, strerror(errno));
	
	
	
	memset(&totoaddr,  0x00, sizeof(struct sockaddr_in));
	totoaddr.sin_family = AF_INET;
	if (strncmp(argv[1],"0.0.0.0",7)==0) totoaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	else                                 totoaddr.sin_addr.s_addr = inet_addr(argv[1]);
	totoaddr.sin_port = htons(atoi(argv[2]));
	
	
	
	/*result=bind(osock, (struct sockaddr*)&listaddr, sizeof(struct sockaddr_in));*/
	/*if (result>=0) printf("%s: result=bind(osock, (struct sockaddr*)&listaddr, sizeof(struct sockaddr_in)): result=%d if (result>=0): Successful listen socket.\n", self, result);*/
	/*else           printf("%s: result=bind(osock, (struct sockaddr*)&listaddr, sizeof(struct sockaddr_in)): result=%d if (result>=0): else: Unable to listen socket, Reason: %d:%s\n", self, result, errno, strerror(errno));*/
	
	
	
	/** @name UDP: listen+accept not suppoted: socket+bind:recvfrom+sendto */
	/*result=listen(osock, maxqueue);*/
	/*if (result>=0) printf("%s: result=listen(osock, maxqueue): result=%d if (result>=0): Successful listen socket.\n", self, result);*/
	/*else           printf("%s: result=listen(osock, maxqueue): result=%d if (result>=0): else: Unable to listen socket, Reason: %d:%s\n", self, result, errno, strerror(errno));*/
	
	
	
	memset(buffdata, 0x00, sizeof(buffdata));
	strncpy(buffdata, "GET / HTTP/1.1\r\n", sizeof(buffdata));
	addrsize=sizeof(struct sockaddr_in);
	
	
	
	memset(ipaddr, 0x00, sizeof(ipaddr));
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	snprintf(ipaddr, sizeof(ipaddr), "%d.%d.%d.%d", (unsigned int)(totoaddr.sin_addr.s_addr&0x000000FF), (unsigned int)(totoaddr.sin_addr.s_addr&0x0000FF00)>>8, (unsigned int)(totoaddr.sin_addr.s_addr&0x00FF0000)>>16, (unsigned int)(totoaddr.sin_addr.s_addr&0xFF000000)>>24);
#else
	inet_ntop(AF_INET, &totoaddr.sin_addr, ipaddr, sizeof(ipaddr));
#endif
	iaport=ntohs(totoaddr.sin_port);
	
	result=sendto(osock, buffdata, strlen(buffdata), 0, (struct sockaddr*)&totoaddr, addrsize);
	if (result>=0) printf("%s: result=sendto(osock=%d, buffdata, strlen(buffdata)=%lu, 0, (struct sockaddr*)&totoaddr=%s:%d, addrsize=%d): result=%d if (result>=0): Successful sendto().\n", self, osock, (long unsigned int)strlen(buffdata), ipaddr, iaport, addrsize, result);
	else           printf("%s: result=sendto(osock=%d, buffdata, strlen(buffdata)=%lu, 0, (struct sockaddr*)&totoaddr=%s:%d, addrsize=%d): result=%d if (result>=0): else: Unable to sendto(), Reason: %d:%s\n", self, osock, (long unsigned int)strlen(buffdata), ipaddr, iaport, addrsize, result, errno, strerror(errno));
	if (result<0) { close(osock); return 0; }
	printf("%s: strlen(buffdata)=%lu result=%d buffdata=|%s|\n", self, (unsigned long int)strlen(buffdata), result, buffdata);
	
	
	
	memset(buffdata, 0x00, sizeof(buffdata));
	addrsize=sizeof(struct sockaddr_in);
	result=recvfrom(osock, buffdata, sizeof(buffdata), 0, (struct sockaddr*)&totoaddr, &addrsize);
	
	memset(ipaddr, 0x00, sizeof(ipaddr));
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	snprintf(ipaddr, sizeof(ipaddr), "%d.%d.%d.%d", (unsigned int)(totoaddr.sin_addr.s_addr&0x000000FF), (unsigned int)(totoaddr.sin_addr.s_addr&0x0000FF00)>>8, (unsigned int)(totoaddr.sin_addr.s_addr&0x00FF0000)>>16, (unsigned int)(totoaddr.sin_addr.s_addr&0xFF000000)>>24);
#else
	inet_ntop(AF_INET, &totoaddr.sin_addr, ipaddr, sizeof(ipaddr));
#endif
	iaport=ntohs(totoaddr.sin_port);
	
	if (result>=0) printf("%s: result=recvfrom(osock=%d, buffdata, sizeof(buffdata)=%u, 0, (struct sockaddr*)&totoaddr=%s:%d, &addrsize=%d): result=%d if (result>=0): Successful recvfrom().\n", self, osock, sizeof(buffdata), ipaddr, iaport, addrsize, result);
	else           printf("%s: result=recvfrom(osock=%d, buffdata, sizeof(buffdata)=%u, 0, (struct sockaddr*)&totoaddr=%s:%d, &addrsize=%d): result=%d if (result>=0): else: Unable to recvfrom(), Reason: %d:%s\n", self, osock, sizeof(buffdata), ipaddr, iaport, addrsize, result, errno, strerror(errno));
	printf("%s: strlen(buffdata)=%lu result=%d buffdata=|%s|\n", self, (unsigned long int)strlen(buffdata), result, buffdata);
	
	
	
	close(osock);
	
	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/sockets/sendto

program wyświetli informacje o sposobie uruchamiania programu:

Usage: /home/local/code/ansiccode/sockets/sendto <udp:ipaddr> <udp:ipport>

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

/home/local/code/ansiccode/sockets/sendto 127.0.0.1 2222

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

sendto: osock=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP): osock=3 if (osock>=0): Successful socket().
sendto: result=sendto(osock=3, buffdata, strlen(buffdata)=16, 0, (struct sockaddr*)&totoaddr=127.0.0.1:2222, addrsize=16): result=16 if (result>=0): Successful sendto().
sendto: strlen(buffdata)=16 result=16 buffdata=|GET / HTTP/1.1
|
sendto: result=recvfrom(osock=3, buffdata, sizeof(buffdata)=16384, 0, (struct sockaddr*)&totoaddr=127.0.0.1:2222, &addrsize=16): result=16 if (result>=0): Successful recvfrom().
sendto: strlen(buffdata)=16 result=16 buffdata=|GET / HTTP/1.1
|

#top setsockopt¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | beej.us | gnu.org

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

/* Set socket FD's option OPTNAME at protocol level LEVEL
   to *OPTVAL (which is OPTLEN bytes long).
   Returns 0 on success, -1 for errors.  */
extern int setsockopt (int __fd, int __level, int __optname,
               __const void *__optval, socklen_t __optlen) __THROW;

Powiązane:
getsockopt(), setsockopt(),

Opis:

Funkcja setsockopt()

Argumenty:
int __fd -
int __level -

int __optname -

for __level SOL_RAW following __optname are defined:

ICMP_FILTER -

for __level SOL_IP : IPPROTO_IP following __optname are defined:

IP_TOS -
IP_TTL - Ustawienie tej opcji (pl.wiki:TTL, en.wiki:TTL) dla wysyłanych pakietów. Ustawienie tej opcji jest bardzo użyteczne i używane najczęściej do wyznaczania trasy pakietów w sieci IP poprzez wysyłanie w standardowym przypadku pakietów UDP (pl.wiki:UDP, en.wiki:UDP). Z tej opcji korzystają m.in. następujące narzędzia wyznaczające trasę pakietów: traceroute(8), tracepath(8). Narzędzie mtr(8) również słuzy do wyznaczania trasy, jednakże sposób działania jest nieco inny, gdyż mtr(8) samodzielnie buduje pakiety wysyłane w sieć.
IP_RECVTTL -
IP_RECVERR -
IP_HDRINCL - Domyślnie nagłówek IPv4|IPv6 jest wypełniany:dodawany automatycznie podczas zapisu/wysyłania danych. Ustawienie niniejszej opcji powoduje wyłączenie automatycznego dodawania nagłówka i przeniesienie tego obowiązku utworzenia kompletnego pakietu (nagłówek+dane) na wywołującego funkcję wysyłającą dane poprze socket. Niejsza opcja jest ustawiana najczęściej dla deksryptorów socket o typie SOCK_RAW i protokole IPROTO_RAW. Ustawienie tej opcji wymaga posiadania uprawnień (proces o efektywnym uid 0 lub właściwość CAP_NET_RAW może otwierać RAW sockets). Kiedy ta opcja jest włączona, wartości ustawione poprzez opcje: [[code:ansiccode:sockets#IP_OPTIONS|IP_OPTIONS], [[code:ansiccode:sockets#IP_TTL|IP_TTL]], [[code:ansiccode:sockets#IP_TOS|IP_TOS]] są ignorowane.
IP_OPTIONS -
IP_MTU_DISCOVER -
IP_MULTICAST_IF -
IP_MULTICAST_TTL -
IP_MULTICAST_LOOP -
IP_ADD_MEMBERSHIP -
IP_DROP_MEMBERSHIP -

for __level SOL_SOCKET following __optname are defined:

SO_DEBUG - Turns on recording of debugging information. This option enables or disables debugging in the underlying protocol modules. This option takes an int value. This is a boolean option.
SO_BINDTODEVICE - Bind socket to given DEVICE:<br :>setsockopt(sock, SOL_SOCKET, SO_BINDTODEVICE, "eth0\0", strlen("eth0\0")+1)
As we see above __optlen is strlen() string describe interface + 1 including 0x00 at the end of string.
SO_ATTACH_FILTER -
SO_TIMESTAMP -
SO_SNDTIMEO -
SO_RCVTIMEO -
SO_BROADCAST - Permits sending of broadcast messages, if this is supported by the protocol. This option takes an int value. This is a boolean option.
SO_REUSEADDR - Specifies that the rules used in validating addresses supplied to bind() should allow reuse of local addresses, if this is supported by the protocol. This option takes an int value. This is a boolean option.
SO_KEEPALIVE - Keeps connections active by enabling the periodic transmission of messages, if this is supported by the protocol. This option takes an int value. If the connected socket fails to respond to these messages, the connection is broken and processes writing to that socket are notified with a SIGPIPE signal. This is a boolean option.
SO_LINGER - Lingers on a close() if data is present. This option controls the action taken when unsent messages queue on a socket and close() is performed. If SO_LINGER is set, the system blocks the process during close() until it can transmit the data or until the time expires. If SO_LINGER is not specified, and close() is issued, the system handles the call in a way that allows the process to continue as quickly as possible. This option takes a linger structure, as defined in the <sys:socket.h> header, to specify the state of the option and linger interval.
SO_OOBINLINE - Leaves received out-of-band data (data marked urgent) in line. This option takes an int value. This is a boolean option.
SO_SNDBUF - Sets send buffer size. This option takes an int value. man 7 tcp: Linux supports RFC 1323 TCP high performance extensions. These include Protection Against Wrapped Sequence Numbers (PAWS), Window Scaling and Timestamps. Window scaling allows the use of large (> 64K) TCP windows in order to support links with high latency or bandwidth. To make use of them, the send and receive buffer sizes must be increased. They can be set globally with the /proc/sys/net/ipv4/tcp_wmem (net.ipv4.tcp_wmem) and /proc/sys/net/ipv4/tcp_rmem (net.ipv4.tcp_rmem) files, or on individual sockets by using the SO_SNDBUF and SO_RCVBUF socket options with the setsockopt(2) call.
The maximum sizes for socket buffers declared via the SO_SNDBUF and SO_RCVBUF mechanisms are limited by the values in the /proc/sys/net/core/rmem_max and /proc/sys/net/core/wmem_max files. Note that TCP actually allocates twice the size of the buffer requested in the setsockopt(2) call, and so a succeeding getsockopt(2) call will not return the same size of buffer as requested in the setsockopt(2) call. TCP uses the extra space for administrative purposes and internal kernel structures, and the /proc file values reflect the larger sizes compared to the actual TCP windows. On individual connections, the socket buffer size must be set prior to the listen(2) or connect(2) calls in order to have it take effect. See socket(7) for more information.
SO_RCVBUF - Sets receive buffer size. This option takes an int value. man 7 tcp: Linux supports RFC 1323 TCP high performance extensions. These include Protection Against Wrapped Sequence Numbers (PAWS), Window Scaling and Timestamps. Window scaling allows the use of large (> 64K) TCP windows in order to support links with high latency or bandwidth. To make use of them, the send and receive buffer sizes must be increased. They can be set globally with the /proc/sys/net/ipv4/tcp_wmem (net.ipv4.tcp_wmem) and /proc/sys/net/ipv4/tcp_rmem (net.ipv4.tcp_rmem) files, or on individual sockets by using the SO_SNDBUF and SO_RCVBUF socket options with the setsockopt(2) call.
The maximum sizes for socket buffers declared via the SO_SNDBUF and SO_RCVBUF mechanisms are limited by the values in the /proc/sys/net/core/rmem_max and /proc/sys/net/core/wmem_max files. Note that TCP actually allocates twice the size of the buffer requested in the setsockopt(2) call, and so a succeeding getsockopt(2) call will not return the same size of buffer as requested in the setsockopt(2) call. TCP uses the extra space for administrative purposes and internal kernel structures, and the /proc file values reflect the larger sizes compared to the actual TCP windows. On individual connections, the socket buffer size must be set prior to the listen(2) or connect(2) calls in order to have it take effect. See socket(7) for more information.
SO_DONTROUTE - Requests that outgoing messages bypass the standard routing facilities. The destination must be on a directly-connected network, and messages are directed to the appropriate network interface according to the destination address. The effect, if any, of this option depends on what protocol is in use. This option takes an int value. This is a boolean option.
SO_RCVLOWAT - Sets the minimum number of bytes to process for socket input operations. The default value for SO_RCVLOWAT is 1. If SO_RCVLOWAT is set to a larger value, blocking receive calls normally wait until they have received the smaller of the low water mark value or the requested amount. (They may return less than the low water mark if an error occurs, a signal is caught, or the type of data next in the receive queue is different than that returned, e.g. out of band data). This option takes an int value. Note that not all implementations allow this option to be set.
SO_RCVTIMEO - Sets the timeout value that specifies the maximum amount of time an input function waits until it completes. It accepts a timeval structure with the number of seconds and microseconds specifying the limit on how long to wait for an input operation to complete. If a receive operation has blocked for this much time without receiving additional data, it returns with a partial count or errno set to [EAGAIN] or [EWOULDBLOCK] if no data were received. The default for this option is zero, which indicates that a receive operation will not time out. This option takes a timeval structure. Note that not all implementations allow this option to be set.
SO_SNDLOWAT - Sets the minimum number of bytes to process for socket output operations. Non-blocking output operations will process no data if flow control does not allow the smaller of the send low water mark value or the entire request to be processed. This option takes an int value. Note that not all implementations allow this option to be set.
SO_SNDTIMEO - Sets the timeout value specifying the amount of time that an output function blocks because flow control prevents data from being sent. If a send operation has blocked for this time, it returns with a partial count or with errno set to [EAGAIN] ore [EWOULDBLOCK] if no data were sent. The default for this option is zero, which indicates that a send operation will not time out. This option stores a timeval structure. Note that not all implementations allow this option to be set.

for __level IPPROTO_TCP following __optname are defined:

TCP_NODELAY -

for __level IPPROTO_UDP following __optname are defined:

const void *__optval -
socklen_t __optlen -

Zwracana wartość:
int -

Example:
zawartość pliku setsockopt.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, */

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
  #define WIN32_LEAN_AND_MEAN
  #include <winsock.h>     /* for SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, AF_INET, PF_INET, socket(), connect(), send(), recv(), sendto(), recvfrom(), shutdown(), */
                           /* for bind(), listen(), accept(), getsockname(), getsockopt(), setsockopt(), */
                           /* for in_addr_t, INADDR_ANY, INADDR_NONE, INADDR_BROADCAST, IPPROTO_TCP, IPPROTO_UDP, IPPROTO_ICMP, IPPROTO_RAW, */
                           /* for struct sockaddr_in, struct in_addr, inet_addr(), struct hostent, gethostbyname(), gethostbyaddr(), */
#else
  #include <fcntl.h>       /* for O_RDONLY, O_WRONLY, O_RDWR, O_CREAT, O_TRUNC, O_APPEND, F_GETFL, F_SETFL, O_NONBLOCK, fcntl(), open(), creat(), */
  #include <sys/socket.h>  /* for bits/socket.h, SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, SOCK_PACKET, AF_UNIX, PF_UNIX, AF_FILE, PF_FILE, AF_INET, PF_INET, MSG_OOB, MSG_PEEK, MSG_DONTWAIT, struct msghdr, struct sockaddr, struct osockaddr, */
                           /* for socket(), bind(), getsockname(), connect(), getpeername(), send(), recv(), sendto(), recvfrom(), sendmsg(), recvmsg(), getsockopt(), setsockopt(), listen(), accept(), shutdown(), sockatmark(), */
  #include <sys/un.h>      /* for struct sockaddr_un, */
  #include <arpa/inet.h>   /* for netinet/in.h, in_addr_t, INADDR_ANY, INADDR_NONE, INADDR_BROADCAST, IPPROTO_TCP, IPPROTO_UDP, IPPROTO_ICMP, IPPROTO_RAW, */
                           /* for struct sockaddr_in, struct in_addr, inet_addr(), inet_ntoa(), inet_pton(), inet_ntop(), inet_aton(), inet_neta(), inet_net_ntop(), inet_net_pton(), */
  #include <netinet/in.h>  /* need in OpenBSD, for in_port_t, in_addr_t, struct in_addr, struct in6_addr, struct sockaddr_in, struct sockaddr_in6, ntohl(), ntohs(), htonl(), htons(), */
  #include <netinet/in_systm.h> /* need in OpenBSD for - typedef u_int32_t n_time - used in netinet/ip.h */
  #include <netinet/ip.h>  /* for struct timestamp, struct iphdr, struct ip, struct ip_timestamp, IP_DF, */
#endif

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
/* C:/Dev-CPP/bin/../lib/gcc/mingw32/3.4.2/../../../../include/winsock.h:32: */
/*typedef u_int SOCKET;*/
#else
typedef int SOCKET;
#endif

/* This is added for compatibility with OS TCP/IP */
#ifndef TCP_NODELAY
/*/usr/include/netinet/tcp.h:40:#define   TCP_NODELAY      1*/      /* Don't delay send to coalesce packets  */
#define TCP_NODELAY                   1          /* Don't delay send to coalesce packets  */
#endif /* TCP_NODELAY */



int main(int argc, char **argv) {
	char *self;
	SOCKET osock;
	int result;
	
	int flags;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	u_long iMode;
#else
#endif
	struct linger soling;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<1) {
		printf("Usage: %s\n", argv[0]);
		return 0;
	}
	
	osock=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	/*osock=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);*/
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osock==INVALID_SOCKET)
#else
	if (osock>=0)
#endif
	                   printf("%s: osock=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP): osock=%d if (osock>=0): Successful socket().\n", self, osock);
	else               printf("%s: osock=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP): osock=%d if (osock>=0): else: Unable to socket(), Reason: %d:%s\n", self, osock, errno, strerror(errno));
	
	
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	iMode=1;
	result=ioctlsocket(osock,FIONBIO,&iMode);
	if (result>=0) printf("%s: result=ioctlsocket(osock=%d,FIONBIO=%lu,&iMode=%lu): result=%d if (osock>=0): Successful getsockopt().\n", self, osock, (long unsigned int)FIONBIO, iMode, result);
	else           printf("%s: result=ioctlsocket(osock=%d,FIONBIO=%lu,&iMode=%lu): result=%d if (osock>=0): else: Unable getsockopt(), Reason: %d:%s\n", self, osock, (long unsigned int)FIONBIO, iMode, result, errno, strerror(errno));
#else
	flags = fcntl(osock,F_GETFL,0);
	result=fcntl(osock,F_SETFL,flags|O_NONBLOCK);
	if (result>=0) printf("%s: result=fcntl(osock=%d,F_SETFL=%d,flags|O_NONBLOCK=%d): result=%d if (osock>=0): Successful getsockopt().\n", self, osock, F_SETFL, flags|O_NONBLOCK, result);
	else           printf("%s: result=fcntl(osock=%d,F_SETFL=%d,flags|O_NONBLOCK=%d): result=%d if (osock>=0): else: Unable getsockopt(), Reason: %d:%s\n", self, osock, F_SETFL, flags|O_NONBLOCK, result, errno, strerror(errno));
#endif
	
	
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	iMode=0;
	result=ioctlsocket(osock,FIONBIO,&iMode);
	if (result>=0) printf("%s: result=ioctlsocket(osock=%d,FIONBIO=%lu,&iMode=%lu): result=%d if (osock>=0): Successful getsockopt().\n", self, osock, (long unsigned int)FIONBIO, iMode, result);
	else           printf("%s: result=ioctlsocket(osock=%d,FIONBIO=%lu,&iMode=%lu): result=%d if (osock>=0): else: Unable getsockopt(), Reason: %d:%s\n", self, osock, (long unsigned int)FIONBIO, iMode, result, errno, strerror(errno));
#else
	flags = fcntl(osock,F_GETFL,0);
	result=fcntl(osock,F_SETFL,flags&~O_NONBLOCK);
	if (result>=0) printf("%s: result=fcntl(osock=%d,F_SETFL=%d,flags&~O_NONBLOCK=%d): result=%d if (osock>=0): Successful getsockopt().\n", self, osock, F_SETFL, flags&~O_NONBLOCK, result);
	else           printf("%s: result=fcntl(osock=%d,F_SETFL=%d,flags&~O_NONBLOCK=%d): result=%d if (osock>=0): else: Unable getsockopt(), Reason: %d:%s\n", self, osock, F_SETFL, flags&~O_NONBLOCK, result, errno, strerror(errno));
#endif
	
	
	
	flags=65536;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	result=setsockopt(osock,SOL_SOCKET,SO_SNDBUF,(char*)&flags,sizeof(int));
#else
	result=setsockopt(osock,SOL_SOCKET,SO_SNDBUF,       &flags,sizeof(int));
#endif
	if (result>=0) printf("%s: result=getsockopt(osock=%d,SOL_SOCKET=%d,SO_SNDBUF=%d,&flags=%d,sizeof(int)=%lu): result=%d if (osock>=0): Successful getsockopt().\n", self, osock, IPPROTO_TCP, SO_SNDBUF, flags, (unsigned long int)sizeof(int), result);
	else           printf("%s: result=getsockopt(osock=%d,SOL_SOCKET=%d,SO_SNDBUF=%d,&flags=%d,sizeof(int)=%lu): result=%d if (osock>=0): else: Unable getsockopt(), Reason: %d:%s\n", self, osock, IPPROTO_TCP, SO_SNDBUF, flags, (unsigned long int)sizeof(int), result, errno, strerror(errno));
	
	
	
	flags=262144;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	result=setsockopt(osock,SOL_SOCKET,SO_RCVBUF,(char*)&flags,sizeof(int));
#else
	result=setsockopt(osock,SOL_SOCKET,SO_RCVBUF,       &flags,sizeof(int));
#endif
	if (result>=0) printf("%s: result=getsockopt(osock=%d,SOL_SOCKET=%d,SO_RCVBUF=%d,&flags=%d,sizeof(int)=%lu): result=%d if (osock>=0): Successful getsockopt().\n", self, osock, IPPROTO_TCP, SO_RCVBUF, flags, (unsigned long int)sizeof(int), result);
	else           printf("%s: result=getsockopt(osock=%d,SOL_SOCKET=%d,SO_RCVBUF=%d,&flags=%d,sizeof(int)=%lu): result=%d if (osock>=0): else: Unable getsockopt(), Reason: %d:%s\n", self, osock, IPPROTO_TCP, SO_RCVBUF, flags, (unsigned long int)sizeof(int), result, errno, strerror(errno));
	
	
	
	flags=1;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	result=setsockopt(osock,SOL_SOCKET,SO_REUSEADDR,(char*)&flags,sizeof(int));
#else
	result=setsockopt(osock,SOL_SOCKET,SO_REUSEADDR,       &flags,sizeof(int));
#endif
	if (result>=0) printf("%s: result=getsockopt(osock=%d,SOL_SOCKET=%d,SO_REUSEADDR=%d,&flags=%d,sizeof(int)=%lu): result=%d if (osock>=0): Successful getsockopt().\n", self, osock, IPPROTO_TCP, SO_REUSEADDR, flags, (unsigned long int)sizeof(int), result);
	else           printf("%s: result=getsockopt(osock=%d,SOL_SOCKET=%d,SO_REUSEADDR=%d,&flags=%d,sizeof(int)=%lu): result=%d if (osock>=0): else: Unable getsockopt(), Reason: %d:%s\n", self, osock, IPPROTO_TCP, SO_REUSEADDR, flags, (unsigned long int)sizeof(int), result, errno, strerror(errno));
	
	
	
	flags=1;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	result=setsockopt(osock,SOL_SOCKET,SO_BROADCAST,(char*)&flags,sizeof(int));
#else
	result=setsockopt(osock,SOL_SOCKET,SO_BROADCAST,       &flags,sizeof(int));
#endif
	if (result>=0) printf("%s: result=getsockopt(osock=%d,SOL_SOCKET=%d,SO_BROADCAST=%d,&flags=%d,sizeof(int)=%lu): result=%d if (osock>=0): Successful getsockopt().\n", self, osock, IPPROTO_TCP, SO_BROADCAST, flags, (unsigned long int)sizeof(int), result);
	else           printf("%s: result=getsockopt(osock=%d,SOL_SOCKET=%d,SO_BROADCAST=%d,&flags=%d,sizeof(int)=%lu): result=%d if (osock>=0): else: Unable getsockopt(), Reason: %d:%s\n", self, osock, IPPROTO_TCP, SO_BROADCAST, flags, (unsigned long int)sizeof(int), result, errno, strerror(errno));
	
	
	
	memset(&soling, 0x00, sizeof(struct linger));
	soling.l_onoff=1;
	soling.l_linger=0;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	result=setsockopt(osock,SOL_SOCKET,SO_LINGER,(char*)&soling,sizeof(struct linger));
#else
	result=setsockopt(osock,SOL_SOCKET,SO_LINGER,       &soling,sizeof(struct linger));
#endif
	if (result>=0) printf("%s: result=getsockopt(osock=%d,SOL_SOCKET=%d,SO_LINGER=%d,&flags=%d,sizeof(int)=%lu): result=%d if (osock>=0): Successful getsockopt().\n", self, osock, IPPROTO_TCP, SO_LINGER, flags, (unsigned long int)sizeof(int), result);
	else           printf("%s: result=getsockopt(osock=%d,SOL_SOCKET=%d,SO_LINGER=%d,&flags=%d,sizeof(int)=%lu): result=%d if (osock>=0): else: Unable getsockopt(), Reason: %d:%s\n", self, osock, IPPROTO_TCP, SO_LINGER, flags, (unsigned long int)sizeof(int), result, errno, strerror(errno));
	
	
	
	flags=1;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	result=setsockopt(osock,IPPROTO_TCP,TCP_NODELAY,(char*)&flags,sizeof(int));
#else
	result=setsockopt(osock,IPPROTO_TCP,TCP_NODELAY,       &flags,sizeof(int));
#endif
	if (result>=0) printf("%s: result=getsockopt(osock=%d,IPPROTO_TCP=%d,TCP_NODELAY=%d,&flags=%d,sizeof(int)=%lu): result=%d if (osock>=0): Successful getsockopt().\n", self, osock, IPPROTO_TCP, TCP_NODELAY, flags, (unsigned long int)sizeof(int), result);
	else           printf("%s: result=getsockopt(osock=%d,IPPROTO_TCP=%d,TCP_NODELAY=%d,&flags=%d,sizeof(int)=%lu): result=%d if (osock>=0): else: Unable getsockopt(), Reason: %d:%s\n", self, osock, IPPROTO_TCP, TCP_NODELAY, flags, (unsigned long int)sizeof(int), result, errno, strerror(errno));
	
	
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
#else
	flags=1;
	result=setsockopt(osock,IPPROTO_IP,IP_DF,          &flags,sizeof(int));
	if (result>=0) printf("%s: result=getsockopt(osock=%d,IPPROTO_TCP=%d,IP_DF=%d,&flags=%d,sizeof(int)=%lu): result=%d if (osock>=0): Successful getsockopt().\n", self, osock, IPPROTO_TCP, IP_DF, flags, (unsigned long int)sizeof(int), result);
	else           printf("%s: result=getsockopt(osock=%d,IPPROTO_TCP=%d,IP_DF=%d,&flags=%d,sizeof(int)=%lu): result=%d if (osock>=0): else: Unable getsockopt(), Reason: %d:%s\n", self, osock, IPPROTO_TCP, IP_DF, flags, (unsigned long int)sizeof(int), result, 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/sockets/select

program wyświetli informacje o sposobie uruchamiania programu:

Usage: /home/local/code/ansiccode/sockets/select <tcp:ipaddr> <tcp:ipport>

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

/home/local/code/ansiccode/sockets/select 0.0.0.0 2222

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

select: osock=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP): osock=3 if (osock>=0): Successful socket().
select: result=connect(osock, (struct sockaddr *)&destaddr, sizeof(struct sockaddr_in)): result=0 if (result>=0): Successful connect().
select: result=send(osock, buffdata+buffsend, strlen(buffdata)-buffsend, 0): result=65 if (result>=0): Successful send().
select: strlen(buffdata)=65 buffsend=65 buffdata=|GET /globals.php HTTP/1.0
Host: 127.0.0.1
Connection: close

|
select: result=recv(osock, buffline, sizeof(buffline), MSG_PEEK): result=117 if (result>=0): Successful recv().
select: result=recv(osock, buffline, strlen(buffdata)-buffrecv-1, 0): result=117 linesize=27
select: result=recv(osock, buffdata+buffrecv, linesize, MSG_DONTWAIT): result=27 if (result>=0): Successful recv().
select: result=recv(osock, buffline, sizeof(buffline), MSG_PEEK): result=90 if (result>=0): Successful recv().
select: result=recv(osock, buffline, strlen(buffdata)-buffrecv-1, 0): result=90 linesize=17
select: result=recv(osock, buffdata+buffrecv, linesize, MSG_DONTWAIT): result=17 if (result>=0): Successful recv().
select: result=recv(osock, buffline, sizeof(buffline), MSG_PEEK): result=73 if (result>=0): Successful recv().
select: result=recv(osock, buffline, strlen(buffdata)-buffrecv-1, 0): result=73 linesize=19
select: result=recv(osock, buffdata+buffrecv, linesize, MSG_DONTWAIT): result=19 if (result>=0): Successful recv().
select: result=recv(osock, buffline, sizeof(buffline), MSG_PEEK): result=54 if (result>=0): Successful recv().
select: result=recv(osock, buffline, strlen(buffdata)-buffrecv-1, 0): result=54 linesize=2 Found empty line
select: result=recv(osock, buffdata+buffrecv, linesize, MSG_DONTWAIT): result=2 if (result>=0): Successful recv().
select: result=recv(osock, buffline, sizeof(buffline), MSG_PEEK): result=52 if (result>=0): Successful recv().
select: result=recv(osock, buffline, strlen(buffdata)-buffrecv-1, 0): result=52 Unable to find new line (\x0D\x0A)
select: buffrecv=65 HEAD: buffdata=|GET /globals.php HTTP/1.0
Host: 127.0.0.1
Connection: close

|
select: result=52 buffrecv=0
select: result=recv(osock, buffdata+buffrecv, sizeof(buffdata)-buffrecv-1, 0): result=52 if (result>=0): Successful recv().
select: result=0 buffrecv=52
select: result=recv(osock, buffdata+buffrecv, sizeof(buffdata)-buffrecv-1, 0): result=0 if (result>=0): Successful recv().
select: buffrecv=52 BODY: buffdata=|recvaddr=127.0.0.1:2222
buffrecv(HTTP HEAD size)=65
|
select: result=shutdown(osock=3, SHUT_RD=0): result=0 if (result>=0): Successful shutdown().
select: result=shutdown(osock=3, SHUT_WR=1): result=0 if (result>=0): Successful shutdown().
select: result=shutdown(osock=3, SHUT_RDWR=2): result=-1 if (result>=0): else: Unable to shutdown(), Reason: 107:Transport endpoint is not connected

#top shutdown¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | beej.us | gnu.org

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

/* Shut down all or part of the connection open on socket FD.
   HOW determines what to shut down:
     SHUT_RD   = No more receptions;
     SHUT_WR   = No more transmissions;
     SHUT_RDWR = No more receptions or transmissions.
   Returns 0 on success, -1 for errors.  */
extern int shutdown (int __fd, int __how) __THROW;

Powiązane:
connect(), poll(), recv(), select(), send(), shutdown(),

Opis:

Funkcja shutdown()

Argumenty:
int __fd -
int __how - HOW determines what to shut down:

SHUT_RD = No more receptions;
SHUT_WR = No more transmissions;
SHUT_RDWR = No more receptions or transmissions.

Zwracana wartość:
int -

#top sockatmark¶

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

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

/* Determine wheter socket is at a out-of-band mark.  */
extern int sockatmark (int __fd) __THROW;

Powiązane:
socket(), socketpair(), sockatmark(),

Opis:

Funkcja sockatmark()

Argumenty:
int __fd -

Zwracana wartość:
int -

Example:
zawartość pliku sockatmark.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, */

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
  #define WIN32_LEAN_AND_MEAN
  #include <winsock.h>     /* for SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, AF_INET, PF_INET, socket(), connect(), send(), recv(), sendto(), recvfrom(), shutdown(), */
                           /* for bind(), listen(), accept(), getsockname(), getsockopt(), setsockopt(), */
                           /* for in_addr_t, INADDR_ANY, INADDR_NONE, INADDR_BROADCAST, IPPROTO_TCP, IPPROTO_UDP, IPPROTO_ICMP, IPPROTO_RAW, */
                           /* for struct sockaddr_in, struct in_addr, inet_addr(), struct hostent, gethostbyname(), gethostbyaddr(), */
#else
  #include <sys/time.h>    /* for struct timezone, struct timeval, gettimeofday(), settimeofday(), utimes(), lutimes(), futimes(), futimesat(), */
  #include <sys/socket.h>  /* for bits/socket.h, SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, SOCK_PACKET, AF_UNIX, PF_UNIX, AF_FILE, PF_FILE, AF_INET, PF_INET, MSG_OOB, MSG_PEEK, MSG_DONTWAIT, struct msghdr, struct sockaddr, struct osockaddr, */
                           /* for socket(), bind(), getsockname(), connect(), getpeername(), send(), recv(), sendto(), recvfrom(), sendmsg(), recvmsg(), getsockopt(), setsockopt(), listen(), accept(), shutdown(), sockatmark(), */
  #include <arpa/inet.h>   /* for netinet/in.h, in_addr_t, INADDR_ANY, INADDR_NONE, INADDR_BROADCAST, IPPROTO_TCP, IPPROTO_UDP, IPPROTO_ICMP, IPPROTO_RAW, */
                           /* for struct sockaddr_in, struct in_addr, inet_addr(), inet_ntoa(), inet_pton(), inet_ntop(), inet_aton(), inet_neta(), inet_net_ntop(), inet_net_pton(), */
  #include <netinet/in.h>  /* need in OpenBSD, for in_port_t, in_addr_t, struct in_addr, struct in6_addr, struct sockaddr_in, struct sockaddr_in6, ntohl(), ntohs(), htonl(), htons(), */
  #include <netinet/in_systm.h> /* need in OpenBSD for - typedef u_int32_t n_time - used in netinet/ip.h */
#endif

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
/* C:/Dev-CPP/bin/../lib/gcc/mingw32/3.4.2/../../../../include/winsock.h:32: */
/*typedef u_int SOCKET;*/
#else
typedef int SOCKET;
#endif



#define BUFFSIZE 4096

int main(int argc, char **argv) {
	char *self;
	SOCKET osock;
	struct sockaddr_in tcpaddr;
	
	double tmoutrecv;
	struct timeval strtvrecv;
	fd_set fdsrd;
	
	char buffdata[BUFFSIZE];
#if defined(HAVE_SOCKATMARK)
	char oobdata[BUFFSIZE];
	int atmark;
#endif
	int buffsend;
	int result;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<3) {
		printf("Usage: %s <tcp:ipaddr> <tcp:ipport>\n", argv[0]);
		return 0;
	}
	
	tmoutrecv=10;
	osock=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osock!=INVALID_SOCKET)
#else
	if (osock>=0)
#endif
	                   { printf("%s: osock=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP): osock=%d if (osock>=0): Successful socket().\n", self, osock); }
	else               { printf("%s: osock=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP): osock=%d if (osock>=0): else: Unable to socket(), Reason: %d:%s\n", self, osock, errno, strerror(errno)); return 0; }
	
	
	
	memset(&tcpaddr,  0x00, sizeof(struct sockaddr_in));
	tcpaddr.sin_family = AF_INET;
	tcpaddr.sin_addr.s_addr = inet_addr(argv[1]);
	tcpaddr.sin_port = htons(atoi(argv[2]));
	
	
	
	result=connect(osock, (struct sockaddr *)&tcpaddr, sizeof(struct sockaddr_in));
	if (result>=0) { printf("%s: result=connect(osock, (struct sockaddr *)&tcpaddr, sizeof(struct sockaddr_in)): result=%d if (result>=0): Successful connect().\n", self, result); }
	else           { printf("%s: result=connect(osock, (struct sockaddr *)&tcpaddr, sizeof(struct sockaddr_in)): result=%d if (result>=0): else: Unable to connect(), Reason: %d:%s\n", self, result, errno, strerror(errno)); close(osock); return 0; }
	
	
	
	/** @name create REQUEST */
	memset(buffdata, 0x00, sizeof(buffdata));
	strncat(buffdata, "GET /globals.php HTTP/1.0\r\n", sizeof(buffdata)-strlen(buffdata)-1);
	strncat(buffdata, "Host: ", sizeof(buffdata)-strlen(buffdata)-1); strncat(buffdata, argv[1], sizeof(buffdata)-strlen(buffdata)-1); strncat(buffdata, "\r\n", sizeof(buffdata)-strlen(buffdata)-1);
	strncat(buffdata, "Connection: close\r\n", sizeof(buffdata)-strlen(buffdata)-1);
	strncat(buffdata, "\r\n", sizeof(buffdata)-strlen(buffdata)-1);
	
	
	
	/** @name send REQUEST */
	buffsend=0;
	while (buffsend<(int)strlen(buffdata)) {
		result=send(osock, buffdata+buffsend, strlen(buffdata)-buffsend, 0);
		if (result>=0) printf("%s: result=send(osockaftcp, buffdata+buffsend, strlen(buffdata)-buffsend, 0): result=%d if (result>=0): Successful send().\n", self, result);
		else           printf("%s: result=send(osockaftcp, buffdata+buffsend, strlen(buffdata)-buffsend, 0): result=%d if (result>=0): else: Unable to send(), Reason: %d:%s\n", self, result, errno, strerror(errno));
		if      (result >0) buffsend=buffsend+result;
		else if (result==0) break;
		else                { close(osock); return 0; }
	}
	printf("%s: strlen(buffdata)=%lu buffsend=%d buffdata=|%s|\n", self, (unsigned long int)strlen(buffdata), buffsend, buffdata);
	
	
	
	strtvrecv.tv_sec  = (int)tmoutrecv;
	strtvrecv.tv_usec = (int)( 1E6*(tmoutrecv-(double)strtvrecv.tv_sec) );
	
	FD_ZERO(&fdsrd);
	FD_SET(osock, &fdsrd);
	result=select(osock+1, &fdsrd, NULL, NULL, &strtvrecv);
	if (result==0) { printf("%s: result=select(osock+1, &fdsrd, NULL, NULL, &strtvrecv): result=%d if (result==0) return RES_TIMEOUT;\n", self, result);   return 2; }
	if (result <0) { printf("%s: result=select(osock+1, &fdsrd, NULL, NULL, &strtvrecv): result=%d if (result <0) return RES_SOCKERROR;\n", self, result); return 2; }
	
	
	
	for (;;) {
#if defined(HAVE_SOCKATMARK)
		atmark = sockatmark(osock);
		if (atmark==-1) {
			printf("%s: atmark = sockatmark(osock=%d): result=%d if (result==-1): Unable to sockatmark(), Reason: %d:%s\n", self, osock, result, errno, strerror(errno));
			close(osock);
			return 0;
		}
		
		if (atmark) break;
#endif
		
		result=read(osock, buffdata, sizeof(buffdata));
		if (result==-1) {
			printf("%s: result=read(osock=%d, buffdata, sizeof(buffdata)=%u): result=%d if (result==-1): Unable to read(), Reason: %d:%s\n", self, osock,sizeof(buffdata), result, errno, strerror(errno));
			close(osock);
			return 2;
		}
		if (result<=0) break;
	}
	
#if defined(HAVE_SOCKATMARK)
	if (atmark==1) {
		result=recv(osock, oobdata, sizeof(oobdata), MSG_OOB);
		if (result==-1) {
			printf("%s: result=recv(osock=%d, oobdata, sizeof(oobdata)=%d, MSG_OOB): result=%d if (result==-1): Unable to recv(), Reason: %d:%s\n", self, osock, sizeof(oobdata), result, errno, strerror(errno));
			close(osock);
			return 3;
		}
		printf("%s: result=recv(osock=%d, oobdata, sizeof(oobdata)=%u, MSG_OOB): result=%d oobdata=|%s|\n", self, osock, sizeof(oobdata), result, oobdata);
	}
#endif
	
	close(osock);
	
	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/sockets/sockatmark

program wyświetli informacje o sposobie uruchamiania programu:

Usage: /home/local/code/ansiccode/sockets/sockatmark <tcp:ipaddr> <tcp:ipport>

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

/home/local/code/ansiccode/sockets/sockatmark 0.0.0.0 2222

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

sockatmark: osock=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP): osock=3 if (osock>=0): Successful socket().
sockatmark: result=connect(osock, (struct sockaddr *)&tcpaddr, sizeof(struct sockaddr_in)): result=0 if (result>=0): Successful connect().
sockatmark: result=send(osockaftcp, buffdata+buffsend, strlen(buffdata)-buffsend, 0): result=63 if (result>=0): Successful send().
sockatmark: strlen(buffdata)=63 buffsend=63 buffdata=|GET /globals.php HTTP/1.0
Host: 0.0.0.0
Connection: close

|

#top socket¶

Documentacja online: pubs.opengroup.org | www.cplusplus.com | pl.wikibooks.org | beej.us | gnu.org

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

/* Create a new socket of type TYPE in domain DOMAIN, using
   protocol PROTOCOL.  If PROTOCOL is zero, one is chosen automatically.
   Returns a file descriptor for the new socket, or -1 for errors.  */
extern int socket (int __domain, int __type, int __protocol) __THROW;

Powiązane:
socket(), socketpair(), sockatmark(),

Opis:

Funkcja socket()

Argumenty:
int __domain -

int __type -

int __protocol -

Zwracana wartość:
int -

Example:
zawartość pliku socket.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, */

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
  #define WIN32_LEAN_AND_MEAN
  #include <winsock.h>     /* for SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, AF_INET, PF_INET, socket(), connect(), send(), recv(), sendto(), recvfrom(), shutdown(), */
                           /* for bind(), listen(), accept(), getsockname(), getsockopt(), setsockopt(), */
                           /* for in_addr_t, INADDR_ANY, INADDR_NONE, INADDR_BROADCAST, IPPROTO_TCP, IPPROTO_UDP, IPPROTO_ICMP, IPPROTO_RAW, */
                           /* for struct sockaddr_in, struct in_addr, inet_addr(), struct hostent, gethostbyname(), gethostbyaddr(), */
#else
  #include <sys/socket.h>  /* for bits/socket.h, SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, SOCK_PACKET, AF_UNIX, PF_UNIX, AF_FILE, PF_FILE, AF_INET, PF_INET, MSG_OOB, MSG_PEEK, MSG_DONTWAIT, struct msghdr, struct sockaddr, struct osockaddr, */
                           /* for socket(), bind(), getsockname(), connect(), getpeername(), send(), recv(), sendto(), recvfrom(), sendmsg(), recvmsg(), getsockopt(), setsockopt(), listen(), accept(), shutdown(), sockatmark(), */
  #include <sys/un.h>      /* for struct sockaddr_un, */
  #include <arpa/inet.h>   /* for netinet/in.h, in_addr_t, INADDR_ANY, INADDR_NONE, INADDR_BROADCAST, IPPROTO_TCP, IPPROTO_UDP, IPPROTO_ICMP, IPPROTO_RAW, */
                           /* for struct sockaddr_in, struct in_addr, inet_addr(), inet_ntoa(), inet_pton(), inet_ntop(), inet_aton(), inet_neta(), inet_net_ntop(), inet_net_pton(), */
  #include <netinet/in.h>  /* need in OpenBSD, for in_port_t, in_addr_t, struct in_addr, struct in6_addr, struct sockaddr_in, struct sockaddr_in6, ntohl(), ntohs(), htonl(), htons(), */
  #include <netinet/in_systm.h> /* need in OpenBSD for - typedef u_int32_t n_time - used in netinet/ip.h */
#endif

#ifndef AF_FILE
#define AF_FILE AF_UNIX
#endif

#ifndef AF_LOCAL
#define AF_LOCAL AF_UNIX
#endif

#ifndef PF_FILE
#define PF_FILE PF_UNIX
#endif

#ifndef PF_LOCAL
#define PF_LOCAL PF_UNIX
#endif

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
/* C:/Dev-CPP/bin/../lib/gcc/mingw32/3.4.2/../../../../include/winsock.h:32: */
/*typedef u_int SOCKET;*/
#else
typedef int SOCKET;
#endif



int main(int argc, char **argv) {
	char *self;
	SOCKET osockaftcp;
	SOCKET osockpftcp;
	
	SOCKET osockafudp;
	SOCKET osockpfudp;
	
	SOCKET osockaflocal;
	SOCKET osockpflocal;
	SOCKET osockafunix;
	SOCKET osockpfunix;
	SOCKET osockaffile;
	SOCKET osockpffile;
	
	self=strrchr(argv[0], '/');
	if (self!=NULL) self++;
	else self=argv[0];
	
	if (argc<1) {
		printf("Usage: %s\n", argv[0]);
		return 0;
	}
	
	
	
	osockaftcp=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockaftcp==INVALID_SOCKET)
#else
	if (osockaftcp>=0)
#endif
	                   printf("%s: osockaftcp=socket(AF_INET=%d, SOCK_STREAM=%d, IPPROTO_TCP=%d): osockaftcp=%d if (osock>=0): Successful socket().\n", self, AF_INET, SOCK_STREAM, IPPROTO_TCP, osockaftcp);
	else               printf("%s: osockaftcp=socket(AF_INET=%d, SOCK_STREAM=%d, IPPROTO_TCP=%d): osockaftcp=%d if (osock>=0): else: Unable to socket(), Reason: %d:%s\n", self, AF_INET, SOCK_STREAM, IPPROTO_TCP, osockaftcp, errno, strerror(errno));
	
	osockpftcp=socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockpftcp==INVALID_SOCKET)
#else
	if (osockpftcp>=0)
#endif
	                   printf("%s: osockpftcp=socket(PF_INET=%d, SOCK_STREAM=%d, IPPROTO_TCP=%d): osockpftcp=%d if (osockpftcp>=0): Successful socket().\n", self, PF_INET, SOCK_STREAM, IPPROTO_TCP, osockpftcp);
	else               printf("%s: osockpftcp=socket(PF_INET=%d, SOCK_STREAM=%d, IPPROTO_TCP=%d): osockpftcp=%d if (osockpftcp>=0): else: Unable to socket(), Reason: %d:%s\n", self, PF_INET, SOCK_STREAM, IPPROTO_TCP, osockpftcp, errno, strerror(errno));
	
	
	
	osockafudp=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockafudp==INVALID_SOCKET)
#else
	if (osockafudp>=0)
#endif
	                   printf("%s: osockafudp=socket(AF_INET=%d, SOCK_DGRAM=%d, IPPROTO_UDP=%d): osockafudp=%d if (osockafudp>=0): Successful socket().\n", self, AF_INET, SOCK_DGRAM, IPPROTO_UDP, osockafudp);
	else               printf("%s: osockafudp=socket(AF_INET=%d, SOCK_DGRAM=%d, IPPROTO_UDP=%d): osockafudp=%d if (osockafudp>=0): else: Unable to socket(), Reason: %d:%s\n", self, AF_INET, SOCK_DGRAM, IPPROTO_UDP, osockafudp, errno, strerror(errno));
	
	osockpfudp=socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockpfudp==INVALID_SOCKET)
#else
	if (osockpfudp>=0)
#endif
	                   printf("%s: osockpfudp=socket(PF_INET=%d, SOCK_DGRAM=%d, IPPROTO_UDP=%d): osockpfudp=%d if (osockpfudp>=0): Successful socket().\n", self, PF_INET, SOCK_DGRAM, IPPROTO_UDP, osockpfudp);
	else               printf("%s: osockpfudp=socket(PF_INET=%d, SOCK_DGRAM=%d, IPPROTO_UDP=%d): osockpfudp=%d if (osockpfudp>=0): else: Unable to socket(), Reason: %d:%s\n", self, PF_INET, SOCK_DGRAM, IPPROTO_UDP, osockpfudp, errno, strerror(errno));
	
	
	
	osockaflocal=socket(AF_LOCAL, SOCK_STREAM, 0);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockaflocal==INVALID_SOCKET)
#else
	if (osockaflocal>=0)
#endif
	                     printf("%s: osockaflocal=socket(AF_LOCAL=%d, SOCK_STREAM=%d, 0): osockaflocal=%d if (osockaflocal>=0): Successful socket().\n", self, AF_LOCAL, SOCK_STREAM, osockaflocal);
	else                 printf("%s: osockaflocal=socket(AF_LOCAL=%d, SOCK_STREAM=%d, 0): osockaflocal=%d if (osockaflocal>=0): else: Unable to socket(), Reason: %d:%s\n", self, AF_LOCAL, SOCK_STREAM, osockaflocal, errno, strerror(errno));
	
	osockpflocal=socket(PF_LOCAL, SOCK_STREAM, 0);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockpflocal==INVALID_SOCKET)
#else
	if (osockpflocal>=0)
#endif
	                     printf("%s: osockpflocal=socket(PF_LOCAL=%d, SOCK_STREAM=%d, 0): osockpflocal=%d if (osockpflocal>=0): Successful socket().\n", self, PF_LOCAL, SOCK_STREAM, osockpflocal);
	else                 printf("%s: osockpflocal=socket(PF_LOCAL=%d, SOCK_STREAM=%d, 0): osockpflocal=%d if (osockpflocal>=0): else: Unable to socket(), Reason: %d:%s\n", self, PF_LOCAL, SOCK_STREAM, osockpflocal, errno, strerror(errno));
	
	
	
	osockafunix=socket(AF_UNIX, SOCK_STREAM, 0);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockafunix==INVALID_SOCKET)
#else
	if (osockafunix>=0)
#endif
	                    printf("%s: osockafunix=socket(AF_INET=%d, SOCK_STREAM=%d, 0): osockafunix=%d if (osockafunix>=0): Successful socket().\n", self, AF_INET, SOCK_STREAM, osockafunix);
	else                printf("%s: osockafunix=socket(AF_INET=%d, SOCK_STREAM=%d, 0): osockafunix=%d if (osockafunix>=0): else: Unable to socket(), Reason: %d:%s\n", self, AF_INET, SOCK_STREAM, osockafunix, errno, strerror(errno));
	
	osockpfunix=socket(PF_UNIX, SOCK_STREAM, 0);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockpfunix==INVALID_SOCKET)
#else
	if (osockpfunix>=0)
#endif
	                    printf("%s: osockpfunix=socket(PF_UNIX=%d, SOCK_STREAM=%d, 0): osockpfunix=%d if (osockpfunix>=0): Successful socket().\n", self, PF_UNIX, SOCK_STREAM, osockpfunix);
	else                printf("%s: osockpfunix=socket(PF_UNIX=%d, SOCK_STREAM=%d, 0): osockpfunix=%d if (osockpfunix>=0): else: Unable to socket(), Reason: %d:%s\n", self, PF_UNIX, SOCK_STREAM, osockpfunix, errno, strerror(errno));
	
	
	
	osockaffile=socket(AF_FILE, SOCK_STREAM, 0);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockaffile==INVALID_SOCKET)
#else
	if (osockaffile>=0)
#endif
	                    printf("%s: osockaffile=socket(AF_FILE=%d, SOCK_STREAM=%d, 0): osockaffile=%d if (osockaffile>=0): Successful socket().\n", self, AF_INET, SOCK_STREAM, osockaffile);
	else                printf("%s: osockaffile=socket(AF_FILE=%d, SOCK_STREAM=%d, 0): osockaffile=%d if (osockaffile>=0): else: Unable to socket(), Reason: %d:%s\n", self, AF_INET, SOCK_STREAM, osockaffile, errno, strerror(errno));
	
	osockpffile=socket(PF_FILE, SOCK_STREAM, 0);
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockpffile==INVALID_SOCKET)
#else
	if (osockpffile>=0)
#endif
	                    printf("%s: osockpffile=socket(PF_FILE=%d, SOCK_STREAM=%d, 0): osockpffile=%d if (osockpffile>=0): Successful socket().\n", self, PF_FILE, SOCK_STREAM, osockpffile);
	else                printf("%s: osockpffile=socket(PF_FILE=%d, SOCK_STREAM=%d, 0): osockpffile=%d if (osockpffile>=0): else: Unable to socket(), Reason: %d:%s\n", self, PF_FILE, SOCK_STREAM, osockpffile, errno, strerror(errno));
	
	
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockaftcp!=INVALID_SOCKET) close(osockaftcp);
#else
	if (osockaftcp>=0) close(osockaftcp);
#endif
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockpftcp!=INVALID_SOCKET) close(osockpftcp);
#else
	if (osockpftcp>=0) close(osockpftcp);
#endif
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockafudp!=INVALID_SOCKET) close(osockafudp);
#else
	if (osockafudp>=0) close(osockafudp);
#endif
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockpfudp!=INVALID_SOCKET) close(osockpfudp);
#else
	if (osockpfudp>=0) close(osockpfudp);
#endif
	
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockaflocal!=INVALID_SOCKET) close(osockaflocal);
#else
	if (osockaflocal>=0) close(osockaflocal);
#endif
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockpflocal!=INVALID_SOCKET) close(osockpflocal);
#else
	if (osockpflocal>=0) close(osockpflocal);
#endif
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockafunix>=INVALID_SOCKET) close(osockafunix);
#else
	if (osockafunix>=0) close(osockafunix);
#endif
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockpfunix!=INVALID_SOCKET) close(osockpfunix);
#else
	if (osockpfunix>=0) close(osockpfunix);
#endif
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockaffile!=INVALID_SOCKET) close(osockaffile);
#else
	if (osockaffile>=0) close(osockaffile);
#endif
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
	if (osockpffile!=INVALID_SOCKET) close(osockpffile);
#else
	if (osockpffile>=0) close(osockpffile);
#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/sockets/socket

program wyświetli informacje o sposobie działania:

socket: osockaftcp=socket(AF_INET=2, SOCK_STREAM=1, IPPROTO_TCP=6): osockaftcp=3 if (osock>=0): Successful socket().
socket: osockpftcp=socket(PF_INET=2, SOCK_STREAM=1, IPPROTO_TCP=6): osockpftcp=4 if (osockpftcp>=0): Successful socket().
socket: osockafudp=socket(AF_INET=2, SOCK_DGRAM=2, IPPROTO_UDP=17): osockafudp=5 if (osockafudp>=0): Successful socket().
socket: osockpfudp=socket(PF_INET=2, SOCK_DGRAM=2, IPPROTO_UDP=17): osockpfudp=6 if (osockpfudp>=0): Successful socket().
socket: osockaflocal=socket(AF_LOCAL=1, SOCK_STREAM=1, 0): osockaflocal=7 if (osockaflocal>=0): Successful socket().
socket: osockpflocal=socket(PF_LOCAL=1, SOCK_STREAM=1, 0): osockpflocal=8 if (osockpflocal>=0): Successful socket().
socket: osockafunix=socket(AF_INET=2, SOCK_STREAM=1, 0): osockafunix=9 if (osockafunix>=0): Successful socket().
socket: osockpfunix=socket(PF_UNIX=1, SOCK_STREAM=1, 0): osockpfunix=10 if (osockpfunix>=0): Successful socket().
socket: osockaffile=socket(AF_FILE=2, SOCK_STREAM=1, 0): osockaffile=11 if (osockaffile>=0): Successful socket().
socket: osockpffile=socket(PF_FILE=1, SOCK_STREAM=1, 0): osockpffile=12 if (osockpffile>=0): Successful socket().

#top socketpair¶

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

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

/* Create two new sockets, of type TYPE in domain DOMAIN and using
   protocol PROTOCOL, which are connected to each other, and put file
   descriptors for them in FDS[0] and FDS[1].  If PROTOCOL is zero,
   one will be chosen automatically.  Returns 0 on success, -1 for errors.  */
extern int socketpair (int __domain, int __type, int __protocol,
               int __fds[2]) __THROW;

Powiązane:
socket(), socketpair(), sockatmark(),

Opis:

Funkcja socketpair()

Argumenty:
int __domain -
int __type -
int __protocol -
int __fds[2] -

Zwracana wartość:
int -

Example:
zawartość pliku socketpair.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, */
#include <ctype.h>         /* for tolower(), toupper(), isctype(), isascii(), toascii(), isalnum(), isalpha(), iscntrl(), isdigit(), islower(), isgraph(), isprint(), ispunct(), isspace(), isupper(), isxdigit(), */

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
  #define WIN32_LEAN_AND_MEAN
  #include <winsock.h>     /* for SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, AF_INET, PF_INET, socket(), connect(), send(), recv(), sendto(), recvfrom(), shutdown(), */
                           /* for bind(), listen(), accept(), getsockname(), getsockopt(), setsockopt(), */
                           /* for in_addr_t, INADDR_ANY, INADDR_NONE, INADDR_BROADCAST, IPPROTO_TCP, IPPROTO_UDP, IPPROTO_ICMP, IPPROTO_RAW, */
                           /* for struct sockaddr_in, struct in_addr, inet_addr(), struct hostent, gethostbyname(), gethostbyaddr(), */
#else
  #include <sys/wait.h>    /* for typedef enum idtype_t, wait(), waitpid(), */
  #include <sys/socket.h>  /* for bits/socket.h, SOCK_STREAM, SOCK_DGRAM, SOCK_RAW, SOCK_PACKET, AF_UNIX, PF_UNIX, AF_FILE, PF_FILE, AF_INET, PF_INET, MSG_OOB, MSG_PEEK, MSG_DONTWAIT, struct msghdr, struct sockaddr, struct osockaddr, */
                           /* for socket(), bind(), getsockname(), connect(), getpeername(), send(), recv(), sendto(), recvfrom(), sendmsg(), recvmsg(), getsockopt(), setsockopt(), listen(), accept(), shutdown(), sockatmark(), */
  #include <sys/un.h>      /* for struct sockaddr_un, */
  #include <arpa/inet.h>   /* for netinet/in.h, in_addr_t, INADDR_ANY, INADDR_NONE, INADDR_BROADCAST, IPPROTO_TCP, IPPROTO_UDP, IPPROTO_ICMP, IPPROTO_RAW, */
                           /* for struct sockaddr_in, struct in_addr, inet_addr(), inet_ntoa(), inet_pton(), inet_ntop(), inet_aton(), inet_neta(), inet_net_ntop(), inet_net_pton(), */
  #include <netinet/in.h>  /* need in OpenBSD, for in_port_t, in_addr_t, struct in_addr, struct in6_addr, struct sockaddr_in, struct sockaddr_in6, ntohl(), ntohs(), htonl(), htons(), */
  #include <netinet/in_systm.h> /* need in OpenBSD for - typedef u_int32_t n_time - used in netinet/ip.h */
#endif

#ifndef AF_FILE
#define AF_FILE AF_UNIX
#endif

#ifndef AF_LOCAL
#define AF_LOCAL AF_UNIX
#endif

#ifndef PF_FILE
#define PF_FILE PF_UNIX
#endif

#ifndef PF_LOCAL
#define PF_LOCAL PF_UNIX
#endif

#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
/* C:/Dev-CPP/bin/../lib/gcc/mingw32/3.4.2/../../../../include/winsock.h:32: */
/*typedef u_int SOCKET;*/
#else
typedef int SOCKET;
#endif



int main(int argc, char **argv) {
	char *self;
#if defined(__WIN32__) || defined(WIN32) || defined(_WIN32)
#else
	int result;
	int sockvect[2]; /* the pair of socket descriptors */
	char buffdata; /* for data exchange between processes */
#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)
	/* socketpair() is not available on this OS platform !!! */
	printf("%s: socketpair() is not available on this OS platform !!!\n", self);
	
	/* fork() is not available on this OS platform !!! */
	printf("%s: fork() is not available on this OS platform !!!\n", self);
#else
	result=socketpair(AF_UNIX, SOCK_STREAM, 0, sockvect);
	if (result>=0) {
		printf("%s: result=socketpair(AF_UNIX=%d, SOCK_STREAM=%d, 0, sockvect={%d, %d}): result=%d if (result>=0): Successful socketpair().\n", self, AF_UNIX, SOCK_STREAM, sockvect[0], sockvect[1], result);
	} else {
		printf("%s: result=socketpair(AF_UNIX=%d, SOCK_STREAM=%d, 0, sockvect={%d, %d}): result=%d if (result>=0): else: Unable to socketpair(), Reason: %d:%s\n", self, AF_UNIX, SOCK_STREAM, sockvect[0], sockvect[1], result, errno, strerror(errno));
		return 0;
	}
	
	if (!fork()) {  /* child */
		read(sockvect[1], &buffdata, 1);
		printf("child: read '%c'\n", buffdata);
		buffdata = toupper(buffdata);  /* make it uppercase */
		write(sockvect[1], &buffdata, 1);
		printf("child: sent '%c'\n", buffdata);
	} else { /* parent */
		write(sockvect[0], "b", 1);
		printf("parent: sent 'b'\n");
		read(sockvect[0], &buffdata, 1);
		printf("parent: read '%c'\n", buffdata);
		wait(NULL); /* wait for child to die */
	}
	
	close(sockvect[0]);
	close(sockvect[1]);
#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/sockets/socketpair

program wyświetli informacje o sposobie działania:

socketpair: result=socketpair(AF_UNIX=1, SOCK_STREAM=1, 0, sockvect={3, 4}): result=0 if (result>=0): Successful socketpair().
parent: sent 'b'
child: read 'b'
parent: read 'B'
child: sent 'B'

Zmodyfikowany ostatnio: 2014/12/09 07:33:24 (10 lat temu), textsize: 325 kB, htmlsize: 470 kB

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

Dodaj komentarzKomentarze użytkowników