├── .gitignore ├── DISCLAIMER ├── Make.defines ├── Make.defines.in ├── Makefile ├── Makefile.in ├── README.md ├── VERSION ├── aclocal.m4 ├── advio ├── Makefile ├── daytimetcpcli.c ├── daytimeudpcli3.c ├── daytimeudpcli4.c ├── dgclitimeo.c ├── dgclitimeo1.c ├── dgclitimeo2.c ├── dgclitimeo3.c ├── dgechoaddr.c ├── old │ ├── dgechoaddr.c │ ├── recvfromflags.c │ └── test01.c ├── recvfromflags.c ├── script.1 ├── sig_chld_waitpid.c ├── str_cli_kqueue04.c ├── str_cli_poll03.c ├── str_cli_select02.c ├── str_echo_stdio02.c ├── tcpcli01.c ├── tcpcli02.c ├── tcpcli03.c ├── tcpcli04.c ├── tcpserv02.c ├── udpcli01.c ├── udpcli02.c ├── udpcli03.c ├── udpserv01.c ├── udpserv03.c └── udpserv04.c ├── bcast ├── Makefile ├── dgclibcast1.c ├── dgclibcast2.c ├── dgclibcast3.c ├── dgclibcast4.c ├── dgclibcast5.c ├── dgclibcast6.c ├── udpcli01.c ├── udpcli02.c ├── udpcli03.c ├── udpcli04.c ├── udpcli05.c └── udpcli06.c ├── config.guess ├── config.h ├── config.h.in ├── config.log ├── config.status ├── config.sub ├── configure ├── configure.in ├── debug ├── Makefile ├── backlog.c ├── qlen.c ├── test01.c ├── test02.c ├── test03.c ├── test04.c ├── test05.c ├── test06.c └── unpxti.h ├── icmpd ├── Makefile ├── dgcli01.c ├── icmpd.c ├── icmpd.h ├── readable_conn.c ├── readable_listen.c ├── readable_v4.c ├── readable_v6.c ├── script.1 ├── script.2 ├── script.3 ├── script.4 ├── udpcli01.c └── unpicmpd.h ├── inetd ├── Makefile ├── daytimetcpsrv2.c └── daytimetcpsrv3.c ├── install-sh ├── intro ├── Makefile ├── byteorder.c ├── daytimetcpcli.c ├── daytimetcpcli1.c ├── daytimetcpcli2.c ├── daytimetcpcli3.c ├── daytimetcpcliv6.c ├── daytimetcpsrv.c ├── daytimetcpsrv1.c ├── daytimetcpsrv2.c ├── daytimetcpsrv3.c ├── daytimetcpsrvv6.c ├── truss.solaris.2.6 └── truss.unixware.2.1 ├── ioctl ├── Makefile ├── Progs.siocgifconf ├── Script.solaris ├── lsif01.c ├── lsif02.c ├── prifinfo.c ├── prmac.c └── test1.c ├── ipopts ├── Makefile ├── dgechoprintroute.c ├── sigchldwaitpid.c ├── sourceroute.c ├── sourceroute6.c ├── tcpcli01.c ├── tcpserv01.c ├── udpcli01.c └── udpserv01.c ├── key ├── Makefile ├── add.c ├── dump.c ├── name.c ├── printsadbmsg.c ├── register.c └── unp.h ├── lib ├── Makefile ├── addrinfo.h ├── connect_nonb.c ├── connect_timeo.c ├── daemon_inetd.c ├── daemon_init.c ├── dg_cli.c ├── dg_echo.c ├── error.c ├── family_to_level.c ├── get_ifi_info.c ├── gf_time.c ├── host_serv.c ├── hstrerror.c ├── if_indextoname.c ├── if_nameindex.c ├── if_nametoindex.c ├── in6addr_any.c ├── mcast_get_if.c ├── mcast_get_loop.c ├── mcast_get_ttl.c ├── mcast_join.c ├── mcast_leave.c ├── mcast_set_if.c ├── mcast_set_loop.c ├── mcast_set_ttl.c ├── my_addrs.c ├── pselect.c ├── read_fd.c ├── readable_timeo.c ├── readline.c ├── readn.c ├── rtt.c ├── signal.c ├── signal_intr.c ├── snprintf.c ├── sock_bind_wild.c ├── sock_cmp_addr.c ├── sock_cmp_port.c ├── sock_get_port.c ├── sock_ntop.c ├── sock_ntop_host.c ├── sock_set_addr.c ├── sock_set_port.c ├── sock_set_wild.c ├── sockatmark.c ├── sockfd_to_family.c ├── str_cli.c ├── str_echo.c ├── tcp_connect.c ├── tcp_listen.c ├── tv_sub.c ├── udp_client.c ├── udp_connect.c ├── udp_server.c ├── unp.h ├── unp.lh ├── unpifi.h ├── unprtt.h ├── unprtt.lh ├── unpthread.h ├── wraplib.c ├── wrappthread.c ├── wrapsock.c ├── wrapstdio.c ├── wrapunix.c ├── writable_timeo.c ├── write_fd.c └── writen.c ├── libfree ├── Make.tar ├── Makefile ├── README ├── README.getaddrinfo ├── addrinfo.h ├── getaddrinfo.c ├── getnameinfo.c ├── in_cksum.c ├── inet_aton.c ├── inet_ntop.c ├── inet_ntop_ipv4.c ├── inet_pton.c ├── inet_pton_ipv4.c ├── test_ascii2addr.c ├── test_getservbyname_r.c └── test_inet_pton.c ├── libgai ├── Makefile ├── addrinfo.h ├── freeaddrinfo.c ├── ga_aistruct.c ├── ga_clone.c ├── ga_echeck.c ├── ga_nsearch.c ├── ga_port.c ├── ga_serv.c ├── ga_unix.c ├── gai_hdr.h ├── gai_hdr.lh ├── gai_strerror.c ├── getaddrinfo.c ├── getnameinfo.c ├── gn_ipv46.c ├── old │ ├── ga_unixstruct.c │ └── savecopy.c ├── test1.c └── testga.c ├── libroute ├── Makefile ├── get_rtaddrs.c ├── if_indextoname.c ├── if_nameindex.c ├── if_nametoindex.c ├── net_rt_dump.c ├── net_rt_iflist.c ├── sock_masktop.c └── unproute.h ├── mcast ├── Makefile ├── dgclibcast1.c ├── dgclimcast5.c ├── dgclimcast6.c ├── main.c ├── recv.c ├── send.c ├── udpcli01.c ├── udpcli05.c ├── udpcli06.c └── udpserv01.c ├── mysdr ├── Makefile ├── loop.c ├── main.c ├── mysdr.h ├── script.1 └── script.2 ├── names ├── Makefile ├── daytimetcpcli.c ├── daytimetcpcli1.c ├── daytimetcpcli2.c ├── daytimetcpcli3.c ├── daytimetcpsrv1.c ├── daytimetcpsrv2.c ├── daytimetcpsrv3.c ├── daytimetcpsrv4.c ├── daytimeudpcli1.c ├── daytimeudpcli2.c ├── daytimeudpsrv2.c ├── daytimeudpsrv3.c ├── hostent.c ├── hostent2.c ├── hostent3.c ├── myaddrs1.c ├── netent.c ├── prmyaddrs.c ├── prmyaddrs1.c ├── test1.c ├── test2.c └── udp_server_reuseaddr.c ├── nonblock ├── Makefile ├── daytimetcpcli.c ├── doit.1 ├── home_page.c ├── script.1.sh ├── script.1.tcpd ├── start_connect.c ├── strclifork.c ├── strclinonb.c ├── tcpcli01.c ├── tcpcli02.c ├── tcpcli03.c ├── tcpcli04.c ├── tcpservselect03.c ├── web.c ├── web.h └── write_get_cmd.c ├── oob ├── Makefile ├── heartbeatcli.c ├── heartbeatserv.c ├── sigchldwaitpid.c ├── strcliselect02.c ├── strecho02.c ├── tcpcli02.c ├── tcprecv01.c ├── tcprecv02.c ├── tcprecv03.c ├── tcprecv03p.c ├── tcprecv04.c ├── tcprecv05.c ├── tcprecv06.c ├── tcpsend01.c ├── tcpsend02.c ├── tcpsend03.c ├── tcpsend04.c ├── tcpsend05.c ├── tcpsend06.c └── tcpserv02.c ├── ping ├── Makefile ├── bsdping.c ├── init_v6.c ├── main.c ├── old │ ├── icmp6.h │ └── ip6.h ├── ping.h ├── ping_v4.c ├── proc_v4.c ├── proc_v6.c ├── readloop.c ├── send_v4.c ├── send_v6.c ├── sig_alrm.c └── tv_sub.c ├── route ├── Makefile ├── checkudpsum.c ├── get_ifi_info.c ├── getrt.c ├── mynetstat.c ├── prifindex.c ├── prifinfo.c ├── prifname.c ├── prifnameindex.c └── unproute.h ├── rtt ├── Makefile ├── dg_cli.c ├── dg_echo.c ├── dg_send_recv.c ├── rtt.out.kumba.1 ├── rtt.out.kumba.2 ├── rtt.out.vangogh.1 ├── rtt.out.vangogh.2 ├── rtt.vals.kumba.1 ├── rtt.vals.vangogh.1 ├── udpcli01.c └── unprtt.h ├── sctp ├── Makefile ├── sctp_addr_to_associd.c ├── sctp_bindargs.c ├── sctp_check_notify.c ├── sctp_displayevents.c ├── sctp_getnostrm.c ├── sctp_modify_hb.c ├── sctp_pdapircv.c ├── sctp_print_addrs.c ├── sctp_strcli.c ├── sctp_strcli1.c ├── sctp_strcli_un.c ├── sctp_strcliecho.c ├── sctp_strcliecho2.c ├── sctp_wrapper.c ├── sctpclient01.c ├── sctpclient02.c ├── sctpclient04.c ├── sctpserv01.c ├── sctpserv02.c ├── sctpserv03.c ├── sctpserv04.c ├── sctpserv05.c ├── sctpserv06.c ├── sctpserv07.c ├── sctpserv_fork.c └── unp.h ├── select ├── Makefile ├── strcliselect01.c ├── strcliselect02.c ├── tcpcli01.c ├── tcpcli02.c └── tcpcli03.c ├── server ├── Makefile ├── child.h ├── child.lh ├── child02.c ├── child02l.c ├── child02m.c ├── child03.c ├── child03m.c ├── child04.c ├── child05.c ├── client.c ├── clientrst.c ├── lock_fcntl.c ├── lock_pthread.c ├── meter.c ├── pr_cpu_time.c ├── pthread07.c ├── pthread07.h ├── pthread08.c ├── pthread08.h ├── pthread09.c ├── pthread09.h ├── readline.c ├── readline_r.c ├── readline_r.h ├── serv00.c ├── serv01.c ├── serv02.c ├── serv02m.c ├── serv03.c ├── serv03m.c ├── serv04.c ├── serv05.c ├── serv06.c ├── serv07.c ├── serv08.c ├── serv09.c ├── sig_chld_waitpid.c ├── unpthread.h ├── web_child.c └── web_child_r.c ├── sigio ├── Makefile ├── dgcli01.c ├── dgecho01.c ├── script.1 ├── script.2 ├── udpcli01.c └── udpserv01.c ├── sock ├── Makefile ├── README ├── TODO ├── buffers.c ├── cliopen.c ├── crlf.c ├── error.c ├── loop.c ├── looptcp.c ├── loopudp.c ├── main.c ├── multicast.c ├── ourhdr.h ├── pattern.c ├── servopen.c ├── sinktcp.c ├── sinkudp.c ├── sleepus.c ├── sock.h ├── sock.in ├── sockopts.c ├── sourceroute.c ├── sourcesink.c ├── sourcetcp.c ├── sourceudp.c ├── strerror.c ├── tellwait.c ├── write.c └── writen.c ├── sockopt ├── Makefile ├── checkopts.c ├── prdefaults.c ├── rcvbuf.c ├── rcvbufset.c └── sockopt.c ├── sparc64-unknown-freebsd5.1 └── config.h ├── ssntp ├── Makefile ├── main.c ├── ntp.h ├── sntp.h └── sntp_proc.c ├── streams ├── Makefile ├── stream_dg │ ├── Makefile │ ├── client.c │ ├── net_stream.c │ └── server.c ├── strlist_sock.c ├── strlist_xti.c ├── tpi_bind.c ├── tpi_close.c ├── tpi_connect.c ├── tpi_daytime.c ├── tpi_daytime.h ├── tpi_read.c └── unpxti.h ├── tcpcliserv ├── Makefile ├── sigchldwait.c ├── sigchldwaitpid.c ├── str_cli08.c ├── str_cli09.c ├── str_cli11.c ├── str_echo08.c ├── str_echo09.c ├── sum.h ├── tcpcli01.c ├── tcpcli04.c ├── tcpcli05.c ├── tcpcli06.c ├── tcpcli07.c ├── tcpcli08.c ├── tcpcli09.c ├── tcpcli10.c ├── tcpcli11.c ├── tcpserv01.c ├── tcpserv02.c ├── tcpserv03.c ├── tcpserv04.c ├── tcpserv08.c ├── tcpserv09.c ├── tcpservpoll01.c ├── tcpservselect01.c └── tsigpipe.c ├── test ├── Makefile ├── accept_eintr.c ├── funcs.c ├── readline.h ├── readline1.c ├── readline2.c ├── readline3.c ├── test.h ├── test1.c ├── test2.c ├── tisfdtype.c ├── treadline1.c ├── treadline2.c ├── treadline3.c ├── tshutdown.c └── tsnprintf.c ├── threads ├── Makefile ├── doit.1 ├── doit.2 ├── example01.c ├── example02.c ├── example03.c ├── readline.c ├── script.example01 ├── script.example02 ├── strclithread.c ├── strclithread2.c ├── tcpcli01.c ├── tcpcli02.c ├── tcpserv01.c ├── tcpserv02.c ├── test01.c ├── test02.c ├── test03.c ├── test04.c ├── test05.c ├── unpthread.h ├── web01.c ├── web02.c └── web03.c ├── traceroute ├── Makefile ├── icmpcode_v4.c ├── icmpcode_v6.c ├── main.c ├── recv_v4.c ├── recv_v6.c ├── sig_alrm.c ├── trace.h ├── trace.lh ├── traceloop.c └── tv_sub.c ├── udpcksum ├── Makefile ├── cleanup.c ├── main.c ├── pcap.c ├── senddnsquery-libnet.c ├── senddnsquery-raw.c ├── udpcksum.c ├── udpcksum.h ├── udpread.c ├── udpread.c.bad └── udpwrite.c ├── udpcliserv ├── Makefile ├── dgcliaddr.c ├── dgclibig.c ├── dgcliconnect.c ├── dgcliinetaddr.c ├── dgcliloop1.c ├── dgcliloop3.c ├── dgecholoop1.c ├── dgecholoop2.c ├── sigchldwaitpid.c ├── udpcli01.c ├── udpcli02.c ├── udpcli03.c ├── udpcli04.c ├── udpcli05.c ├── udpcli06.c ├── udpcli08.c ├── udpcli09.c ├── udpcli10.c ├── udpserv01.c ├── udpserv06.c ├── udpserv07.c └── udpservselect01.c └── unixdomain ├── Makefile ├── daytimetcpcli.c ├── daytimetcpsrv2.c ├── mycat.c ├── myopen.c ├── openfile.c ├── readcred.c ├── sigchldwaitpid.c ├── strecho.c ├── testfcred.c ├── tfcred01.c ├── unixbind.c ├── unixdgcli01.c ├── unixdgserv01.c ├── unixstrcli01.c ├── unixstrserv01.c └── unixstrserv02.c /.gitignore: -------------------------------------------------------------------------------- 1 | # temp file generated due to using Emacs 2 | \#* 3 | .#* 4 | *~ 5 | 6 | # object file 7 | *.o 8 | libunp.a 9 | 10 | # output file,such a.out 11 | *.out 12 | *.lc 13 | 14 | TAGS -------------------------------------------------------------------------------- /DISCLAIMER: -------------------------------------------------------------------------------- 1 | LIMITS OF LIABILITY AND DISCLAIMER OF WARRANTY 2 | 3 | The authors and publisher of the book "UNIX Network Programming" have 4 | used their best efforts in preparing this software. These efforts 5 | include the development, research, and testing of the theories and 6 | programs to determine their effectiveness. The authors and publisher 7 | make no warranty of any kind, express or implied, with regard to 8 | these programs or the documentation contained in the book. The authors 9 | and publisher shall not be liable in any event for incidental or 10 | consequential damages in connection with, or arising out of, the 11 | furnishing, performance, or use of these programs. 12 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | include ./Make.defines 2 | 3 | all: 4 | @echo "Nothing to make in this directory" 5 | @echo "Please read the README file" 6 | 7 | clean: 8 | rm -f $(CLEANFILES) 9 | 10 | distclean: 11 | rm -f $(CLEANFILES) config.cache config.log config.status config.h Make.defines Makefile 12 | -------------------------------------------------------------------------------- /Makefile.in: -------------------------------------------------------------------------------- 1 | include ./Make.defines 2 | 3 | all: 4 | @echo "Nothing to make in this directory" 5 | @echo "Please read the README file" 6 | 7 | clean: 8 | rm -f $(CLEANFILES) 9 | 10 | distclean: 11 | rm -f $(CLEANFILES) config.cache config.log config.status config.h Make.defines Makefile 12 | -------------------------------------------------------------------------------- /VERSION: -------------------------------------------------------------------------------- 1 | 2004/12/12 2 | -------------------------------------------------------------------------------- /advio/daytimetcpcli.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd, n, npend; 7 | char recvline[MAXLINE + 1]; 8 | socklen_t len; 9 | struct sockaddr_storage ss; 10 | 11 | if (argc != 3) 12 | err_quit("usage: a.out "); 13 | 14 | sockfd = Tcp_connect(argv[1], argv[2]); 15 | 16 | len = sizeof(ss); 17 | Getpeername(sockfd, (SA *)&ss, &len); 18 | printf("connected to %s\n", Sock_ntop_host((SA *)&ss, len)); 19 | 20 | for ( ; ; ) { 21 | if ( (n = Recv(sockfd, recvline, MAXLINE, MSG_PEEK)) == 0) 22 | break; /* server closed connection */ 23 | 24 | Ioctl(sockfd, FIONREAD, &npend); /* check FIONREAD support */ 25 | printf("%d bytes from PEEK, %d bytes pending\n", n, npend); 26 | 27 | n = Read(sockfd, recvline, MAXLINE); 28 | recvline[n] = 0; /* null terminate */ 29 | Fputs(recvline, stdout); 30 | } 31 | exit(0); 32 | } 33 | -------------------------------------------------------------------------------- /advio/daytimeudpcli3.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd, n, nq; 7 | char recvline[MAXLINE + 1]; 8 | socklen_t salen; 9 | struct sockaddr *sa; 10 | 11 | if (argc != 3) 12 | err_quit("usage: a.out "); 13 | 14 | sockfd = Udp_client(argv[1], argv[2], (void **) &sa, &salen); 15 | 16 | printf("sending to %s\n", Sock_ntop_host(sa, salen)); 17 | 18 | Sendto(sockfd, "", 1, 0, sa, salen); /* send 1-byte datagram */ 19 | 20 | n = Recvfrom(sockfd, recvline, MAXLINE, MSG_PEEK, NULL, NULL); 21 | 22 | Ioctl(sockfd, FIONREAD, &nq); /* check FIONREAD support */ 23 | printf("%d bytes from PEEK, %d bytes pending\n", n, nq); 24 | 25 | n = Recvfrom(sockfd, recvline, MAXLINE, 0, NULL, NULL); 26 | recvline[n] = 0; /* null terminate */ 27 | Fputs(recvline, stdout); 28 | 29 | exit(0); 30 | } 31 | -------------------------------------------------------------------------------- /advio/daytimeudpcli4.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd, n, nq; 7 | char recvline[MAXLINE + 1]; 8 | socklen_t len; 9 | struct sockaddr_storage ss; 10 | 11 | if (argc != 3) 12 | err_quit("usage: a.out "); 13 | 14 | sockfd = Udp_connect(argv[1], argv[2]); 15 | 16 | len = sizeof(ss); 17 | Getpeername(sockfd, (SA *)&ss, &len); 18 | printf("connected to %s\n", Sock_ntop_host((SA *)&ss, len)); 19 | 20 | Write(sockfd, "", 2); /* send 1-byte datagram */ 21 | 22 | n = Recv(sockfd, recvline, MAXLINE, MSG_PEEK); 23 | 24 | Ioctl(sockfd, FIONREAD, &nq); /* check FIONREAD support */ 25 | printf("%d bytes from PEEK, %d bytes pending\n", n, nq); 26 | 27 | n = Read(sockfd, recvline, MAXLINE); 28 | recvline[n] = 0; /* null terminate */ 29 | Fputs(recvline, stdout); 30 | 31 | exit(0); 32 | } 33 | -------------------------------------------------------------------------------- /advio/dgclitimeo.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t servlen) 5 | { 6 | int n; 7 | char sendline[MAXLINE], recvline[MAXLINE + 1]; 8 | 9 | while (Fgets(sendline, MAXLINE, fp) != NULL) { 10 | 11 | Sendto(sockfd, sendline, strlen(sendline), 0, pservaddr, servlen); 12 | 13 | if (Readable_timeo(sockfd, 5) == 0) { 14 | fprintf(stderr, "socket timeout\n"); 15 | continue; 16 | } 17 | n = Recvfrom(sockfd, recvline, MAXLINE, 0, NULL, NULL); 18 | 19 | recvline[n] = 0; /* null terminate */ 20 | Fputs(recvline, stdout); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /advio/dgclitimeo1.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t servlen) 5 | { 6 | int n; 7 | char sendline[MAXLINE], recvline[MAXLINE + 1]; 8 | 9 | while (Fgets(sendline, MAXLINE, fp) != NULL) { 10 | 11 | Sendto(sockfd, sendline, strlen(sendline), 0, pservaddr, servlen); 12 | 13 | if (Readable_timeo(sockfd, 5) == 0) { 14 | fprintf(stderr, "socket timeout\n"); 15 | } else { 16 | n = Recvfrom(sockfd, recvline, MAXLINE, 0, NULL, NULL); 17 | recvline[n] = 0; /* null terminate */ 18 | Fputs(recvline, stdout); 19 | } 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /advio/dgclitimeo2.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t servlen) 5 | { 6 | int n; 7 | char sendline[MAXLINE], recvline[MAXLINE + 1]; 8 | struct timeval tv; 9 | 10 | tv.tv_sec = 5; 11 | tv.tv_usec = 0; 12 | Setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)); 13 | 14 | while (Fgets(sendline, MAXLINE, fp) != NULL) { 15 | 16 | Sendto(sockfd, sendline, strlen(sendline), 0, pservaddr, servlen); 17 | 18 | n = recvfrom(sockfd, recvline, MAXLINE, 0, NULL, NULL); 19 | if (n < 0) { 20 | if (errno == EWOULDBLOCK) { 21 | fprintf(stderr, "socket timeout\n"); 22 | continue; 23 | } else 24 | err_sys("recvfrom error"); 25 | } 26 | 27 | recvline[n] = 0; /* null terminate */ 28 | Fputs(recvline, stdout); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /advio/dgclitimeo3.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | static void sig_alrm(int); 4 | 5 | void 6 | dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t servlen) 7 | { 8 | int n; 9 | char sendline[MAXLINE], recvline[MAXLINE + 1]; 10 | 11 | Signal(SIGALRM, sig_alrm); 12 | 13 | while (Fgets(sendline, MAXLINE, fp) != NULL) { 14 | 15 | Sendto(sockfd, sendline, strlen(sendline), 0, pservaddr, servlen); 16 | 17 | alarm(5); 18 | if ( (n = recvfrom(sockfd, recvline, MAXLINE, 0, NULL, NULL)) < 0) { 19 | if (errno == EINTR) 20 | fprintf(stderr, "socket timeout\n"); 21 | else 22 | err_sys("recvfrom error"); 23 | } else { 24 | alarm(0); 25 | recvline[n] = 0; /* null terminate */ 26 | Fputs(recvline, stdout); 27 | } 28 | } 29 | } 30 | 31 | static void 32 | sig_alrm(int signo) 33 | { 34 | return; /* just interrupt the recvfrom() */ 35 | } 36 | -------------------------------------------------------------------------------- /advio/script.1: -------------------------------------------------------------------------------- 1 | kalae % ./udpserv01 2 | 9-byte datagram from 206.62.226.33.41164, to 206.62.226.35, recv i/f = ef0 3 | 13-byte datagram from 206.62.226.65.1057, to 206.62.226.95, recv i/f = we0 (broadcast) 4 | 4-byte datagram from 206.62.226.33.41176, to 224.0.0.1, recv i/f = ef0 (multicast) 5 | 20-byte datagram from 127.0.0.1.4632, to 127.0.0.1, recv i/f = lo0 (datagram truncated) 6 | 9-byte datagram from 206.62.226.33.41178, to 206.62.226.66, recv i/f = ef0 7 | -------------------------------------------------------------------------------- /advio/sig_chld_waitpid.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | sig_chld(int signo) 5 | { 6 | pid_t pid; 7 | int stat; 8 | 9 | while ( (pid = waitpid(-1, &stat, WNOHANG)) > 0) { 10 | printf("child %d terminated\n", pid); 11 | } 12 | return; 13 | } 14 | -------------------------------------------------------------------------------- /advio/str_echo_stdio02.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | str_echo(int sockfd) 5 | { 6 | char line[MAXLINE]; 7 | FILE *fpin, *fpout; 8 | 9 | fpin = Fdopen(sockfd, "r"); 10 | fpout = Fdopen(sockfd, "w"); 11 | 12 | while (Fgets(line, MAXLINE, fpin) != NULL) 13 | Fputs(line, fpout); 14 | } 15 | -------------------------------------------------------------------------------- /advio/tcpcli01.c: -------------------------------------------------------------------------------- 1 | /* Use standard echo server; baseline measurements for nonblocking version */ 2 | #include "unp.h" 3 | 4 | int 5 | main(int argc, char **argv) 6 | { 7 | int sockfd; 8 | struct sockaddr_in servaddr; 9 | 10 | if (argc != 2) 11 | err_quit("usage: tcpcli "); 12 | 13 | sockfd = Socket(AF_INET, SOCK_STREAM, 0); 14 | 15 | bzero(&servaddr, sizeof(servaddr)); 16 | servaddr.sin_family = AF_INET; 17 | servaddr.sin_port = htons(7); 18 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 19 | 20 | Connect_timeo(sockfd, (SA *) &servaddr, sizeof(servaddr), 10); 21 | 22 | str_cli(stdin, sockfd); /* do it all */ 23 | 24 | exit(0); 25 | } 26 | -------------------------------------------------------------------------------- /advio/tcpcli02.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: tcpcli "); 11 | 12 | sockfd = Socket(AF_INET, SOCK_STREAM, 0); 13 | 14 | bzero(&servaddr, sizeof(servaddr)); 15 | servaddr.sin_family = AF_INET; 16 | servaddr.sin_port = htons(SERV_PORT); 17 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 18 | 19 | Connect(sockfd, (SA *) &servaddr, sizeof(servaddr)); 20 | 21 | str_cli(stdin, sockfd); /* do it all */ 22 | 23 | exit(0); 24 | } 25 | -------------------------------------------------------------------------------- /advio/tcpcli03.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: tcpcli "); 11 | 12 | sockfd = Socket(AF_INET, SOCK_STREAM, 0); 13 | 14 | bzero(&servaddr, sizeof(servaddr)); 15 | servaddr.sin_family = AF_INET; 16 | servaddr.sin_port = htons(SERV_PORT); 17 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 18 | 19 | Connect(sockfd, (SA *) &servaddr, sizeof(servaddr)); 20 | 21 | str_cli(stdin, sockfd); /* do it all */ 22 | 23 | exit(0); 24 | } 25 | -------------------------------------------------------------------------------- /advio/tcpcli04.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: tcpcli "); 11 | 12 | sockfd = Socket(AF_INET, SOCK_STREAM, 0); 13 | 14 | bzero(&servaddr, sizeof(servaddr)); 15 | servaddr.sin_family = AF_INET; 16 | servaddr.sin_port = htons(SERV_PORT); 17 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 18 | 19 | Connect(sockfd, (SA *) &servaddr, sizeof(servaddr)); 20 | 21 | str_cli(stdin, sockfd); /* do it all */ 22 | 23 | exit(0); 24 | } 25 | -------------------------------------------------------------------------------- /advio/udpcli01.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: udpcli "); 11 | 12 | bzero(&servaddr, sizeof(servaddr)); 13 | servaddr.sin_family = AF_INET; 14 | servaddr.sin_port = htons(7); 15 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 16 | 17 | sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 18 | 19 | dg_cli(stdin, sockfd, (SA *) &servaddr, sizeof(servaddr)); 20 | 21 | exit(0); 22 | } 23 | -------------------------------------------------------------------------------- /advio/udpcli02.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: udpcli "); 11 | 12 | bzero(&servaddr, sizeof(servaddr)); 13 | servaddr.sin_family = AF_INET; 14 | servaddr.sin_port = htons(7); 15 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 16 | 17 | sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 18 | 19 | dg_cli(stdin, sockfd, (SA *) &servaddr, sizeof(servaddr)); 20 | 21 | exit(0); 22 | } 23 | -------------------------------------------------------------------------------- /advio/udpcli03.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: udpcli "); 11 | 12 | bzero(&servaddr, sizeof(servaddr)); 13 | servaddr.sin_family = AF_INET; 14 | servaddr.sin_port = htons(7); 15 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 16 | 17 | sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 18 | 19 | dg_cli(stdin, sockfd, (SA *) &servaddr, sizeof(servaddr)); 20 | 21 | exit(0); 22 | } 23 | -------------------------------------------------------------------------------- /advio/udpserv01.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr, cliaddr; 8 | 9 | sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 10 | 11 | bzero(&servaddr, sizeof(servaddr)); 12 | servaddr.sin_family = AF_INET; 13 | servaddr.sin_addr.s_addr = htonl(INADDR_ANY); 14 | servaddr.sin_port = htons(SERV_PORT); 15 | 16 | Bind(sockfd, (SA *) &servaddr, sizeof(servaddr)); 17 | 18 | dg_echo(sockfd, (SA *) &cliaddr, sizeof(cliaddr)); 19 | } 20 | -------------------------------------------------------------------------------- /bcast/udpcli01.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: udpcli01 "); 11 | 12 | bzero(&servaddr, sizeof(servaddr)); 13 | servaddr.sin_family = AF_INET; 14 | servaddr.sin_port = htons(13); /* standard daytime server */ 15 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 16 | 17 | sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 18 | 19 | dg_cli(stdin, sockfd, (SA *) &servaddr, sizeof(servaddr)); 20 | 21 | exit(0); 22 | } 23 | -------------------------------------------------------------------------------- /bcast/udpcli02.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: udpcli02 "); 11 | 12 | bzero(&servaddr, sizeof(servaddr)); 13 | servaddr.sin_family = AF_INET; 14 | servaddr.sin_port = htons(13); /* standard daytime server */ 15 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 16 | 17 | sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 18 | 19 | dg_cli(stdin, sockfd, (SA *) &servaddr, sizeof(servaddr)); 20 | 21 | exit(0); 22 | } 23 | -------------------------------------------------------------------------------- /bcast/udpcli03.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: udpcli03 "); 11 | 12 | bzero(&servaddr, sizeof(servaddr)); 13 | servaddr.sin_family = AF_INET; 14 | servaddr.sin_port = htons(13); /* standard daytime server */ 15 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 16 | 17 | sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 18 | 19 | dg_cli(stdin, sockfd, (SA *) &servaddr, sizeof(servaddr)); 20 | 21 | exit(0); 22 | } 23 | -------------------------------------------------------------------------------- /bcast/udpcli04.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: udpcli04 "); 11 | 12 | bzero(&servaddr, sizeof(servaddr)); 13 | servaddr.sin_family = AF_INET; 14 | servaddr.sin_port = htons(13); /* standard daytime server */ 15 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 16 | 17 | sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 18 | 19 | dg_cli(stdin, sockfd, (SA *) &servaddr, sizeof(servaddr)); 20 | 21 | exit(0); 22 | } 23 | -------------------------------------------------------------------------------- /bcast/udpcli05.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: udpcli05 "); 11 | 12 | bzero(&servaddr, sizeof(servaddr)); 13 | servaddr.sin_family = AF_INET; 14 | servaddr.sin_port = htons(13); /* standard daytime server */ 15 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 16 | 17 | sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 18 | 19 | dg_cli(stdin, sockfd, (SA *) &servaddr, sizeof(servaddr)); 20 | 21 | exit(0); 22 | } 23 | -------------------------------------------------------------------------------- /bcast/udpcli06.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: udpcli02 "); 11 | 12 | bzero(&servaddr, sizeof(servaddr)); 13 | servaddr.sin_family = AF_INET; 14 | servaddr.sin_port = htons(13); /* standard daytime server */ 15 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 16 | 17 | sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 18 | 19 | dg_cli(stdin, sockfd, (SA *) &servaddr, sizeof(servaddr)); 20 | 21 | exit(0); 22 | } 23 | -------------------------------------------------------------------------------- /debug/Makefile: -------------------------------------------------------------------------------- 1 | include ../Make.defines 2 | 3 | PROGS = qlen backlog test01 test02 test03 test04 test05 test06 4 | 5 | all: ${PROGS} 6 | 7 | backlog: backlog.o 8 | ${CC} ${CFLAGS} -o $@ backlog.o ${LIBS} 9 | 10 | qlen: qlen.o 11 | ${CC} ${CFLAGS} -o $@ qlen.o ${LIBS_XTI} 12 | 13 | test01: test01.o 14 | ${CC} ${CFLAGS} -o $@ test01.o ${LIBS_XTI} 15 | 16 | test02: test02.o 17 | ${CC} ${CFLAGS} -o $@ test02.o ${LIBS} 18 | 19 | test03: test03.o 20 | ${CC} ${CFLAGS} -o $@ test03.o ${LIBS_XTI} 21 | 22 | test04: test04.o 23 | ${CC} ${CFLAGS} -o $@ test04.o ${LIBS} 24 | 25 | test05: test05.o 26 | ${CC} ${CFLAGS} -o $@ test05.o ${LIBS_XTI} 27 | 28 | test06: test06.o 29 | ${CC} ${CFLAGS} -o $@ test06.o ${LIBS_XTI} 30 | 31 | clean: 32 | rm -f ${PROGS} ${CLEANFILES} 33 | -------------------------------------------------------------------------------- /debug/test01.c: -------------------------------------------------------------------------------- 1 | #include "unpxti.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int tfd; 7 | 8 | if (argc != 3) 9 | err_quit("usage: test01 "); 10 | 11 | tfd = Tcp_connect(argv[1], argv[2]); 12 | 13 | t_snd(tfd, "", 1, T_EXPEDITED); 14 | 15 | exit(0); 16 | } 17 | -------------------------------------------------------------------------------- /debug/test02.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int fd; 7 | fd_set exset; 8 | 9 | if (argc != 3) 10 | err_quit("usage: test01 "); 11 | 12 | fd = Tcp_connect(argv[1], argv[2]); 13 | 14 | FD_ZERO(&exset); 15 | FD_SET(fd, &exset); 16 | select(fd+1, NULL, NULL, &exset, NULL); 17 | 18 | exit(0); 19 | } 20 | -------------------------------------------------------------------------------- /debug/test03.c: -------------------------------------------------------------------------------- 1 | #include "unpxti.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int listenfd, connfd, n, flags; 7 | char buff[MAXLINE]; 8 | struct pollfd fds[1]; 9 | 10 | if (argc == 2) 11 | listenfd = Tcp_listen(NULL, argv[1], NULL); 12 | else if (argc == 3) 13 | listenfd = Tcp_listen(argv[1], argv[2], NULL); 14 | else 15 | err_quit("usage: daytimetcpsrv01 [ ] "); 16 | 17 | connfd = Xti_accept(listenfd, NULL, 0); 18 | 19 | fds[0].fd = connfd; 20 | fds[0].events = POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI; 21 | for ( ; ; ) { 22 | n = poll(fds, 1, INFTIM); 23 | printf("poll returned %d, revents = 0x%x\n", n, fds[0].revents); 24 | 25 | n = T_rcv(connfd, buff, sizeof(buff), &flags); 26 | printf("received %d bytes, flags = %d\n", n, flags); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /debug/test05.c: -------------------------------------------------------------------------------- 1 | #include "unpxti.h" 2 | 3 | int listenfd, connfd; 4 | 5 | void 6 | sig_poll(int signo) 7 | { 8 | int n, flags; 9 | char buff[MAXLINE]; 10 | 11 | printf("SIGPOLL, event = %d\n", t_look(connfd)); 12 | n = T_rcv(connfd, buff, sizeof(buff), &flags); 13 | printf("received %d bytes, flags = %d\n", n, flags); 14 | } 15 | 16 | int 17 | main(int argc, char **argv) 18 | { 19 | if (argc == 2) 20 | listenfd = Tcp_listen(NULL, argv[1], NULL); 21 | else if (argc == 3) 22 | listenfd = Tcp_listen(argv[1], argv[2], NULL); 23 | else 24 | err_quit("usage: test05 [ ] "); 25 | 26 | connfd = Xti_accept(listenfd, NULL, 0); 27 | 28 | Signal(SIGPOLL, sig_poll); 29 | Ioctl(connfd, I_SETSIG, S_RDNORM); 30 | 31 | for ( ; ; ) { 32 | pause(); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /debug/test06.c: -------------------------------------------------------------------------------- 1 | #include "unpxti.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int fd; 7 | struct t_call *tcall; 8 | 9 | fd = T_open(XTI_TCP, O_RDWR, NULL); 10 | 11 | tcall = T_alloc(fd, T_CALL, T_ALL); 12 | printf("first t_alloc OK\n"); 13 | 14 | tcall = T_alloc(fd, T_CALL, T_ADDR | T_OPT | T_UDATA); 15 | printf("second t_alloc OK\n"); 16 | 17 | exit(0); 18 | } 19 | -------------------------------------------------------------------------------- /icmpd/Makefile: -------------------------------------------------------------------------------- 1 | include ../Make.defines 2 | 3 | OBJS = icmpd.o readable_listen.o readable_conn.o readable_v4.o readable_v6.o 4 | 5 | PROGS = icmpd udpcli01 6 | 7 | all: ${PROGS} 8 | 9 | icmpd: ${OBJS} 10 | ${CC} ${CFLAGS} -o $@ ${OBJS} ${LIBS} 11 | 12 | udpcli01: udpcli01.o dgcli01.o 13 | ${CC} ${CFLAGS} -o $@ udpcli01.o dgcli01.o ${LIBS} 14 | 15 | clean: 16 | rm -f ${PROGS} ${CLEANFILES} 17 | -------------------------------------------------------------------------------- /icmpd/icmpd.h: -------------------------------------------------------------------------------- 1 | #include "unpicmpd.h" 2 | 3 | struct client { 4 | int connfd; /* Unix domain stream socket to client */ 5 | int family; /* AF_INET or AF_INET6 */ 6 | int lport; /* local port bound to client's UDP socket */ 7 | /* network byte ordered */ 8 | } client[FD_SETSIZE]; 9 | 10 | /* 4globals */ 11 | int fd4, fd6, listenfd, maxi, maxfd, nready; 12 | fd_set rset, allset; 13 | struct sockaddr_un cliaddr; 14 | 15 | /* 4function prototypes */ 16 | int readable_conn(int); 17 | int readable_listen(void); 18 | int readable_v4(void); 19 | int readable_v6(void); 20 | -------------------------------------------------------------------------------- /icmpd/readable_listen.c: -------------------------------------------------------------------------------- 1 | #include "icmpd.h" 2 | 3 | int 4 | readable_listen(void) 5 | { 6 | int i, connfd; 7 | socklen_t clilen; 8 | 9 | clilen = sizeof(cliaddr); 10 | connfd = Accept(listenfd, (SA *)&cliaddr, &clilen); 11 | 12 | /* 4find first available client[] structure */ 13 | for (i = 0; i < FD_SETSIZE; i++) 14 | if (client[i].connfd < 0) { 15 | client[i].connfd = connfd; /* save descriptor */ 16 | break; 17 | } 18 | if (i == FD_SETSIZE) { 19 | close(connfd); /* can't handle new client, */ 20 | return(--nready); /* rudely close the new connection */ 21 | } 22 | printf("new connection, i = %d, connfd = %d\n", i, connfd); 23 | 24 | FD_SET(connfd, &allset); /* add new descriptor to set */ 25 | if (connfd > maxfd) 26 | maxfd = connfd; /* for select() */ 27 | if (i > maxi) 28 | maxi = i; /* max index in client[] array */ 29 | 30 | return(--nready); 31 | } 32 | -------------------------------------------------------------------------------- /icmpd/script.1: -------------------------------------------------------------------------------- 1 | kalae % ./udpcli01 198.82.204.99 echo 2 | hello, world 3 | ICMP error: type = 11, code = 0 4 | testing 5 | ICMP error: type = 11, code = 0 6 | 7 | kalae % ./udpcli01 gemini.tuc.noao.edu echo 8 | hi there 9 | ICMP error: type = 3, code = 3 10 | hello 11 | socket timeout 12 | testing 13 | ICMP error: type = 3, code = 3 14 | 15 | -------------------------------------------------------------------------------- /icmpd/script.2: -------------------------------------------------------------------------------- 1 | kalae % ./udpcli01 gemini.tuc.noao.edu echo 2 | hi there 3 | ICMPv4 error: dest = 140.252.8.54.1792, type = 3, code = 3 4 | 5 | 6 | kalae % ./udpcli01 198.82.204.99 echo 7 | hello, world 8 | ICMPv4 error: dest = 198.82.204.99.1792, type = 11, code = 0 9 | testing 10 | ICMPv4 error: dest = 198.82.204.99.1792, type = 11, code = 0 11 | 12 | 13 | -------------------------------------------------------------------------------- /icmpd/script.3: -------------------------------------------------------------------------------- 1 | kohala % ./udpcli01 gemini.tuc.noao.edu echo 2 | hello, world 3 | ICMP error: dest = 140.252.1.11.7, type = 3, code = 3 4 | kohala % 5 | kohala % ./udpcli 198.82.204.99 echo 6 | ksh: ./udpcli: not found 7 | kohala % ./udpcli01 198.82.204.99 echo 8 | hello, world 9 | ICMP error: dest = 198.82.204.99.7, type = 3, code = 3 10 | kohala % ./udpcli01 192.3.4.5.82.204.99 echo 11 | udp_client error for 192.3.4.5.82.204.99, echo: host nor service provided, or not known 12 | kohala % ./udpcli01 192.3.4.5 echo 13 | hello 14 | ICMP error: dest = 192.3.4.5.7, type = 3, code = 1 15 | 16 | 17 | -------------------------------------------------------------------------------- /icmpd/script.4: -------------------------------------------------------------------------------- 1 | kohala % ./udpcli01 192.3.4.5 echo 2 | hi there 3 | socket timeout 4 | and hello 5 | socket timeout 6 | kohala % ./udpcli01 gemini.tuc.noao.edu echo 7 | hello, world 8 | ICMP error: dest = 140.252.4.54.7, Connection refused, type = 3, code = 3 9 | kohala % ./udpcli01 192.3.4.5 echo 10 | hello 11 | ICMP error: dest = 192.3.4.5.7, No route to host, type = 3, code = 1 12 | 13 | -------------------------------------------------------------------------------- /icmpd/udpcli01.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | socklen_t salen; 8 | struct sockaddr *sa; 9 | 10 | if (argc != 3) 11 | err_quit("usage: udpcli01 "); 12 | 13 | sockfd = Udp_client(argv[1], argv[2], &sa, &salen); 14 | 15 | dg_cli(stdin, sockfd, sa, salen); 16 | 17 | exit(0); 18 | } 19 | -------------------------------------------------------------------------------- /icmpd/unpicmpd.h: -------------------------------------------------------------------------------- 1 | #ifndef __unpicmp_h 2 | #define __unpicmp_h 3 | 4 | #include "unp.h" 5 | 6 | #define ICMPD_PATH "/tmp/icmpd" /* server's well-known pathname */ 7 | 8 | struct icmpd_err { 9 | int icmpd_errno;/* EHOSTUNREACH, EMSGSIZE, ECONNREFUSED */ 10 | char icmpd_type; /* actual ICMPv[46] type */ 11 | char icmpd_code; /* actual ICMPv[46] code */ 12 | socklen_t icmpd_len; /* length of sockaddr{} that follows */ 13 | struct sockaddr_storage icmpd_dest; /* sockaddr_storage handles any size */ 14 | }; 15 | 16 | #endif /* __unpicmp_h */ 17 | -------------------------------------------------------------------------------- /inetd/Makefile: -------------------------------------------------------------------------------- 1 | include ../Make.defines 2 | 3 | PROGS = daytimetcpsrv2 daytimetcpsrv3 4 | 5 | all: ${PROGS} 6 | 7 | daytimetcpsrv2: daytimetcpsrv2.o 8 | ${CC} ${CFLAGS} -o $@ daytimetcpsrv2.o ${LIBS} 9 | 10 | daytimetcpsrv3: daytimetcpsrv3.o 11 | ${CC} ${CFLAGS} -o $@ daytimetcpsrv3.o ${LIBS} 12 | 13 | clean: 14 | rm -f ${PROGS} ${CLEANFILES} 15 | -------------------------------------------------------------------------------- /inetd/daytimetcpsrv2.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | #include 3 | 4 | int 5 | main(int argc, char **argv) 6 | { 7 | int listenfd, connfd; 8 | socklen_t addrlen, len; 9 | struct sockaddr *cliaddr; 10 | char buff[MAXLINE]; 11 | time_t ticks; 12 | 13 | if (argc < 2 || argc > 3) 14 | err_quit("usage: daytimetcpsrv2 [ ] "); 15 | 16 | daemon_init(argv[0], 0); 17 | 18 | if (argc == 2) 19 | listenfd = Tcp_listen(NULL, argv[1], &addrlen); 20 | else 21 | listenfd = Tcp_listen(argv[1], argv[2], &addrlen); 22 | 23 | cliaddr = Malloc(addrlen); 24 | 25 | for ( ; ; ) { 26 | len = addrlen; 27 | connfd = Accept(listenfd, cliaddr, &len); 28 | err_msg("connection from %s", Sock_ntop(cliaddr, len)); 29 | 30 | ticks = time(NULL); 31 | snprintf(buff, sizeof(buff), "%.24s\r\n", ctime(&ticks)); 32 | Write(connfd, buff, strlen(buff)); 33 | 34 | Close(connfd); 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /inetd/daytimetcpsrv3.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | #include 3 | 4 | int 5 | main(int argc, char **argv) 6 | { 7 | socklen_t len; 8 | struct sockaddr *cliaddr; 9 | char buff[MAXLINE]; 10 | time_t ticks; 11 | 12 | daemon_inetd(argv[0], 0); 13 | 14 | cliaddr = Malloc(sizeof(struct sockaddr_storage)); 15 | len = sizeof(struct sockaddr_storage); 16 | Getpeername(0, cliaddr, &len); 17 | err_msg("connection from %s", Sock_ntop(cliaddr, len)); 18 | 19 | ticks = time(NULL); 20 | snprintf(buff, sizeof(buff), "%.24s\r\n", ctime(&ticks)); 21 | Write(0, buff, strlen(buff)); 22 | 23 | Close(0); /* close TCP connection */ 24 | exit(0); 25 | } 26 | -------------------------------------------------------------------------------- /intro/byteorder.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | union { 7 | short s; 8 | char c[sizeof(short)]; 9 | } un; 10 | 11 | un.s = 0x0102; 12 | printf("un.s is %d.\n", un.s); 13 | /* printf("%s: ", CPU_VENDOR_OS); */ 14 | if (sizeof(short) == 2) { 15 | if (un.c[0] == 1 && un.c[1] == 2) 16 | printf("big-endian\n"); 17 | else if (un.c[0] == 2 && un.c[1] == 1) 18 | printf("little-endian\n"); 19 | else 20 | printf("unknown\n"); 21 | } else 22 | /* printf("sizeof(short) = %d\n", sizeof(short)); */ 23 | printf("sizeof(short) = %zu\n", sizeof(short)); 24 | 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /intro/daytimetcpsrv.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | #include 3 | 4 | int 5 | main(int argc, char **argv) 6 | { 7 | int listenfd, connfd; 8 | struct sockaddr_in servaddr; 9 | char buff[MAXLINE]; 10 | time_t ticks; 11 | 12 | listenfd = Socket(AF_INET, SOCK_STREAM, 0); 13 | 14 | bzero(&servaddr, sizeof(servaddr)); 15 | servaddr.sin_family = AF_INET; 16 | servaddr.sin_addr.s_addr = htonl(INADDR_ANY); 17 | servaddr.sin_port = htons(13); /* daytime server */ 18 | 19 | Bind(listenfd, (SA *) &servaddr, sizeof(servaddr)); 20 | 21 | Listen(listenfd, LISTENQ); 22 | 23 | for ( ; ; ) { 24 | connfd = Accept(listenfd, (SA *) NULL, NULL); 25 | 26 | ticks = time(NULL); 27 | snprintf(buff, sizeof(buff), "%.24s\r\n", ctime(&ticks)); 28 | Write(connfd, buff, strlen(buff)); 29 | 30 | Close(connfd); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /intro/daytimetcpsrv2.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | #include 3 | 4 | int 5 | main(int argc, char **argv) 6 | { 7 | int listenfd, connfd, i; 8 | struct sockaddr_in servaddr; 9 | char buff[MAXLINE]; 10 | time_t ticks; 11 | 12 | listenfd = Socket(AF_INET, SOCK_STREAM, 0); 13 | 14 | bzero(&servaddr, sizeof(servaddr)); 15 | servaddr.sin_family = AF_INET; 16 | servaddr.sin_addr.s_addr = htonl(INADDR_ANY); 17 | servaddr.sin_port = htons(9999); 18 | 19 | Bind(listenfd, (SA *) &servaddr, sizeof(servaddr)); 20 | 21 | Listen(listenfd, LISTENQ); 22 | 23 | for ( ; ; ) { 24 | connfd = Accept(listenfd, (SA *) NULL, NULL); 25 | 26 | ticks = time(NULL); 27 | snprintf(buff, sizeof(buff), "%.24s\r\n", ctime(&ticks)); 28 | for (i = 0; i < strlen(buff); i++) 29 | Write(connfd, &buff[i], 1); 30 | 31 | Close(connfd); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /intro/truss.solaris.2.6: -------------------------------------------------------------------------------- 1 | so_socket(2, 2, 0, "", 1) = 3 2 | connect(3, 0xEFFFE8C8, 16) = 0 3 | read(3, " F r i A p r 4 1".., 4096) = 26 4 | ioctl(1, TCGETA, 0xEFFFE69C) = 0 5 | write(1, " F r i A p r 4 1".., 26) = 26 6 | read(3, 0xEFFFE8D8, 4096) = 0 7 | llseek(0, 0, SEEK_CUR) = 179866 8 | _exit(0) 9 | -------------------------------------------------------------------------------- /ioctl/Makefile: -------------------------------------------------------------------------------- 1 | include ../Make.defines 2 | 3 | PROGS = lsif01 lsif02 prifinfo prmac 4 | 5 | all: ${PROGS} 6 | 7 | lsif01: lsif01.o 8 | ${CC} ${CFLAGS} -o $@ lsif01.o ${LIBS} 9 | 10 | lsif02: lsif02.o 11 | ${CC} ${CFLAGS} -o $@ lsif02.o ${LIBS} 12 | 13 | prifinfo: prifinfo.o 14 | ${CC} ${CFLAGS} -o $@ prifinfo.o ${LIBS} 15 | 16 | prmac: prmac.o 17 | ${CC} ${CFLAGS} -o $@ prmac.o ${LIBS} 18 | 19 | test1: test1.o 20 | ${CC} ${CFLAGS} -o $@ test1.o ${LIBS} 21 | 22 | clean: 23 | rm -f ${PROGS} ${CLEANFILES} 24 | -------------------------------------------------------------------------------- /ioctl/Script.solaris: -------------------------------------------------------------------------------- 1 | kohala % ./prifinfo 4 1 2 | trying len = 64 3 | ioctl error 4 | trying len = 96 5 | ioctl error 6 | trying len = 128 7 | ioctl error 8 | trying len = 160 9 | ioctl error 10 | trying len = 192 11 | returned len = 160 12 | trying len = 224 13 | returned len = 160 14 | success, len = 160 15 | lo0: 16 | IP addr: 127.0.0.1 17 | le0: 18 | IP addr: 206.62.226.33 19 | broadcast addr: 206.62.226.63 20 | le0:1: 21 | IP addr: 140.252.13.47 22 | broadcast addr: 140.252.13.63 23 | le0:2: 24 | IP addr: 140.252.13.48 25 | broadcast addr: 140.252.13.63 26 | le0:3: 27 | IP addr: 140.252.13.49 28 | broadcast addr: 140.252.13.63 29 | -------------------------------------------------------------------------------- /ioctl/prmac.c: -------------------------------------------------------------------------------- 1 | #include "unpifi.h" 2 | #include 3 | 4 | int 5 | main(int argc, char **argv) 6 | { 7 | int sockfd; 8 | struct ifi_info *ifi; 9 | unsigned char *ptr; 10 | struct arpreq arpreq; 11 | struct sockaddr_in *sin; 12 | 13 | sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 14 | for (ifi = get_ifi_info(AF_INET, 0); ifi != NULL; ifi = ifi->ifi_next) { 15 | printf("%s: ", Sock_ntop(ifi->ifi_addr, sizeof(struct sockaddr_in))); 16 | 17 | sin = (struct sockaddr_in *) &arpreq.arp_pa; 18 | memcpy(sin, ifi->ifi_addr, sizeof(struct sockaddr_in)); 19 | 20 | if (ioctl(sockfd, SIOCGARP, &arpreq) < 0) { 21 | err_ret("ioctl SIOCGARP"); 22 | continue; 23 | } 24 | 25 | ptr = &arpreq.arp_ha.sa_data[0]; 26 | printf("%x:%x:%x:%x:%x:%x\n", *ptr, *(ptr+1), 27 | *(ptr+2), *(ptr+3), *(ptr+4), *(ptr+5)); 28 | } 29 | exit(0); 30 | } 31 | -------------------------------------------------------------------------------- /ioctl/test1.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | #include 3 | 4 | int 5 | main(int argc, char **argv) 6 | { 7 | int i, sockfd, numif; 8 | char buf[1024]; 9 | 10 | sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 11 | 12 | numif = 999; 13 | Ioctl(sockfd, SIOCGIFNUM, &numif); 14 | printf("numif = %d\n", numif); 15 | 16 | i = ioctl(sockfd, SIOCGHIWAT, &buf); 17 | printf("i = %d, errno = %d\n", i, errno); 18 | exit(0); 19 | } 20 | -------------------------------------------------------------------------------- /ipopts/Makefile: -------------------------------------------------------------------------------- 1 | include ../Make.defines 2 | 3 | PROGS = tcpcli01 tcpserv01 4 | 5 | all: ${PROGS} 6 | 7 | tcpcli01: tcpcli01.o sourceroute.o 8 | ${CC} ${CFLAGS} -o $@ tcpcli01.o sourceroute.o ${LIBS} 9 | 10 | tcpserv01: tcpserv01.o sourceroute.o sigchldwaitpid.o 11 | ${CC} ${CFLAGS} -o $@ tcpserv01.o sourceroute.o sigchldwaitpid.o \ 12 | ${LIBS} 13 | 14 | udpcli01: udpcli01.o 15 | ${CC} ${CFLAGS} -o $@ udpcli01.o ${LIBS} 16 | 17 | udpserv01: udpserv01.o sourceroute6.o dgechoprintroute.o 18 | ${CC} ${CFLAGS} -o $@ udpserv01.o sourceroute6.o dgechoprintroute.o ${LIBS} 19 | 20 | 21 | clean: 22 | rm -f ${PROGS} ${CLEANFILES} 23 | -------------------------------------------------------------------------------- /ipopts/sigchldwaitpid.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | sig_chld(int signo) 5 | { 6 | pid_t pid; 7 | int stat; 8 | 9 | while ( (pid = waitpid(-1, &stat, WNOHANG)) > 0) { 10 | printf("child %d terminated\n", pid); 11 | } 12 | return; 13 | } 14 | -------------------------------------------------------------------------------- /ipopts/sourceroute6.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | inet6_srcrt_print(void *ptr) 5 | { 6 | int i, segments; 7 | char str[INET6_ADDRSTRLEN]; 8 | 9 | segments = Inet6_rth_segments(ptr); 10 | printf("received source route: "); 11 | for (i = 0; i < segments; i++) 12 | printf("%s ", Inet_ntop(AF_INET6, Inet6_rth_getaddr(ptr, i), 13 | str, sizeof(str))); 14 | printf("\n"); 15 | } 16 | -------------------------------------------------------------------------------- /ipopts/udpserv01.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in6 servaddr, cliaddr; 8 | 9 | sockfd = Socket(AF_INET6, SOCK_DGRAM, 0); 10 | 11 | bzero(&servaddr, sizeof(servaddr)); 12 | servaddr.sin6_family = AF_INET6; 13 | servaddr.sin6_addr = in6addr_any; 14 | servaddr.sin6_port = htons(SERV_PORT); 15 | 16 | Bind(sockfd, (SA *) &servaddr, sizeof(servaddr)); 17 | 18 | dg_echo(sockfd, (SA *) &cliaddr, sizeof(cliaddr)); 19 | } 20 | -------------------------------------------------------------------------------- /key/Makefile: -------------------------------------------------------------------------------- 1 | include ../Make.defines 2 | 3 | PROGS = dump register add 4 | OBJS = printsadbmsg.o name.o 5 | 6 | all: ${PROGS} 7 | 8 | dump: dump.o ${OBJS} 9 | ${CC} ${CFLAGS} -o $@ $@.o ${OBJS} ${LIBS} 10 | 11 | register: register.o ${OBJS} 12 | ${CC} ${CFLAGS} -o $@ $@.o ${OBJS} ${LIBS} 13 | 14 | add: add.o ${OBJS} 15 | ${CC} ${CFLAGS} -o $@ $@.o ${OBJS} ${LIBS} 16 | -------------------------------------------------------------------------------- /lib/Makefile: -------------------------------------------------------------------------------- 1 | include ../Make.defines 2 | 3 | all: ${LIB_OBJS} 4 | ar rv ${LIBUNP_NAME} $? 5 | ${RANLIB} ${LIBUNP_NAME} 6 | 7 | clean: 8 | rm -f ${PROGS} ${CLEANFILES} 9 | -------------------------------------------------------------------------------- /lib/daemon_inetd.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | #include 3 | 4 | extern int daemon_proc; /* defined in error.c */ 5 | 6 | void 7 | daemon_inetd(const char *pname, int facility) 8 | { 9 | daemon_proc = 1; /* for our err_XXX() functions */ 10 | openlog(pname, LOG_PID, facility); 11 | } 12 | -------------------------------------------------------------------------------- /lib/dg_cli.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t servlen) 5 | { 6 | int n; 7 | char sendline[MAXLINE], recvline[MAXLINE + 1]; 8 | 9 | while (Fgets(sendline, MAXLINE, fp) != NULL) { 10 | 11 | Sendto(sockfd, sendline, strlen(sendline), 0, pservaddr, servlen); 12 | 13 | n = Recvfrom(sockfd, recvline, MAXLINE, 0, NULL, NULL); 14 | 15 | recvline[n] = 0; /* null terminate */ 16 | Fputs(recvline, stdout); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /lib/dg_echo.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | dg_echo(int sockfd, SA *pcliaddr, socklen_t clilen) 5 | { 6 | int n; 7 | socklen_t len; 8 | char mesg[MAXLINE]; 9 | 10 | for ( ; ; ) { 11 | len = clilen; 12 | n = Recvfrom(sockfd, mesg, MAXLINE, 0, pcliaddr, &len); 13 | 14 | Sendto(sockfd, mesg, n, 0, pcliaddr, len); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /lib/family_to_level.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | family_to_level(int family) 5 | { 6 | switch (family) { 7 | case AF_INET: 8 | return IPPROTO_IP; 9 | #ifdef IPV6 10 | case AF_INET6: 11 | return IPPROTO_IPV6; 12 | #endif 13 | default: 14 | return -1; 15 | } 16 | } 17 | 18 | int 19 | Family_to_level(int family) 20 | { 21 | int rc; 22 | 23 | if ( (rc = family_to_level(family)) < 0) 24 | err_sys("family_to_level error"); 25 | 26 | return(rc); 27 | } 28 | -------------------------------------------------------------------------------- /lib/gf_time.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | #include 3 | 4 | char * 5 | gf_time(void) 6 | { 7 | struct timeval tv; 8 | time_t t; 9 | static char str[30]; 10 | char *ptr; 11 | 12 | if (gettimeofday(&tv, NULL) < 0) 13 | err_sys("gettimeofday error"); 14 | 15 | t = tv.tv_sec; /* POSIX says tv.tv_sec is time_t; some BSDs don't agree. */ 16 | ptr = ctime(&t); 17 | strcpy(str, &ptr[11]); 18 | /* Fri Sep 13 00:00:00 1986\n\0 */ 19 | /* 0123456789012345678901234 5 */ 20 | snprintf(str+8, sizeof(str)-8, ".%06ld", tv.tv_usec); 21 | 22 | return(str); 23 | } 24 | -------------------------------------------------------------------------------- /lib/hstrerror.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Return a string containing some additional information after a 3 | * host name or address lookup error - gethostbyname() or gethostbyaddr(). 4 | * 5 | * This is only compiled if the local host does not provide it--recent 6 | * versions of BIND supply this function. 7 | */ 8 | 9 | #include "unp.h" 10 | 11 | const char * 12 | hstrerror(int err) 13 | { 14 | if (err == 0) 15 | return("no error"); 16 | 17 | if (err == HOST_NOT_FOUND) 18 | return("Unknown host"); 19 | 20 | if (err == TRY_AGAIN) 21 | return("Hostname lookup failure"); 22 | 23 | if (err == NO_RECOVERY) 24 | return("Unknown server error"); 25 | 26 | if (err == NO_DATA) 27 | return("No address associated with name"); 28 | 29 | return("unknown error"); 30 | } 31 | -------------------------------------------------------------------------------- /lib/if_indextoname.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | /* 4 | * This is a placeholder if the system does not provide this RFC 2133 5 | * function. If routing sockets with sysctl() are provided, then the 6 | * if_XXX() functions in the libroute/ directory will replace these. 7 | */ 8 | 9 | char * 10 | if_indextoname(unsigned int index, char *name) 11 | { 12 | return(NULL); 13 | } 14 | 15 | char * 16 | If_indextoname(unsigned int index, char *name) 17 | { 18 | char *ptr; 19 | 20 | if ( (ptr = if_indextoname(index, name)) == NULL) 21 | err_quit("if_indextoname error for %d", index); 22 | return(ptr); 23 | } 24 | -------------------------------------------------------------------------------- /lib/if_nameindex.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | /* 4 | * This is a placeholder if the system does not provide this RFC 2133 5 | * function. If routing sockets with sysctl() are provided, then the 6 | * if_XXX() functions in the libroute/ directory will replace these. 7 | */ 8 | 9 | struct if_nameindex * 10 | if_nameindex(void) 11 | { 12 | return(NULL); 13 | } 14 | 15 | void 16 | if_freenameindex(struct if_nameindex *ptr) 17 | { 18 | } 19 | 20 | struct if_nameindex * 21 | If_nameindex(void) 22 | { 23 | struct if_nameindex *ifptr; 24 | 25 | if ( (ifptr = if_nameindex()) == NULL) 26 | err_quit("if_nameindex error"); 27 | return(ifptr); 28 | } 29 | -------------------------------------------------------------------------------- /lib/if_nametoindex.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | /* 4 | * This is a placeholder if the system does not provide this RFC 2133 5 | * function. If routing sockets with sysctl() are provided, then the 6 | * if_XXX() functions in the libroute/ directory will replace these. 7 | */ 8 | 9 | unsigned int 10 | if_nametoindex(const char *name) 11 | { 12 | return(0); 13 | } 14 | 15 | unsigned int 16 | If_nametoindex(const char *name) 17 | { 18 | int index; 19 | 20 | if ( (index = if_nametoindex(name)) == 0) 21 | err_quit("if_nametoindex error for %s", name); 22 | return(index); 23 | } 24 | -------------------------------------------------------------------------------- /lib/in6addr_any.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | #ifdef IPV6 4 | const struct in6_addr in6addr_any; 5 | #endif 6 | -------------------------------------------------------------------------------- /lib/mcast_get_if.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | mcast_get_if(int sockfd) 5 | { 6 | switch (sockfd_to_family(sockfd)) { 7 | case AF_INET: { 8 | /* TODO: similar to mcast_set_if() */ 9 | return(-1); 10 | } 11 | 12 | #ifdef IPV6 13 | case AF_INET6: { 14 | u_int idx; 15 | socklen_t len; 16 | 17 | len = sizeof(idx); 18 | if (getsockopt(sockfd, IPPROTO_IPV6, IPV6_MULTICAST_IF, 19 | &idx, &len) < 0) 20 | return(-1); 21 | return(idx); 22 | } 23 | #endif 24 | 25 | default: 26 | errno = EAFNOSUPPORT; 27 | return(-1); 28 | } 29 | } 30 | 31 | int 32 | Mcast_get_if(int sockfd) 33 | { 34 | int rc; 35 | 36 | if ( (rc = mcast_get_if(sockfd)) < 0) 37 | err_sys("mcast_get_if error"); 38 | return(rc); 39 | } 40 | -------------------------------------------------------------------------------- /lib/mcast_get_loop.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | mcast_get_loop(int sockfd) 5 | { 6 | switch (sockfd_to_family(sockfd)) { 7 | case AF_INET: { 8 | u_char flag; 9 | socklen_t len; 10 | 11 | len = sizeof(flag); 12 | if (getsockopt(sockfd, IPPROTO_IP, IP_MULTICAST_LOOP, 13 | &flag, &len) < 0) 14 | return(-1); 15 | return(flag); 16 | } 17 | 18 | #ifdef IPV6 19 | case AF_INET6: { 20 | u_int flag; 21 | socklen_t len; 22 | 23 | len = sizeof(flag); 24 | if (getsockopt(sockfd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, 25 | &flag, &len) < 0) 26 | return(-1); 27 | return(flag); 28 | } 29 | #endif 30 | 31 | default: 32 | errno = EAFNOSUPPORT; 33 | return(-1); 34 | } 35 | } 36 | 37 | int 38 | Mcast_get_loop(int sockfd) 39 | { 40 | int rc; 41 | 42 | if ( (rc = mcast_get_loop(sockfd)) < 0) 43 | err_sys("mcast_get_loop error"); 44 | return(rc); 45 | } 46 | -------------------------------------------------------------------------------- /lib/mcast_get_ttl.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | mcast_get_ttl(int sockfd) 5 | { 6 | switch (sockfd_to_family(sockfd)) { 7 | case AF_INET: { 8 | u_char ttl; 9 | socklen_t len; 10 | 11 | len = sizeof(ttl); 12 | if (getsockopt(sockfd, IPPROTO_IP, IP_MULTICAST_TTL, 13 | &ttl, &len) < 0) 14 | return(-1); 15 | return(ttl); 16 | } 17 | 18 | #ifdef IPV6 19 | case AF_INET6: { 20 | int hop; 21 | socklen_t len; 22 | 23 | len = sizeof(hop); 24 | if (getsockopt(sockfd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, 25 | &hop, &len) < 0) 26 | return(-1); 27 | return(hop); 28 | } 29 | #endif 30 | 31 | default: 32 | errno = EAFNOSUPPORT; 33 | return(-1); 34 | } 35 | } 36 | 37 | int 38 | Mcast_get_ttl(int sockfd) 39 | { 40 | int rc; 41 | 42 | if ( (rc = mcast_get_ttl(sockfd)) < 0) 43 | err_sys("mcast_get_ttl error"); 44 | return(rc); 45 | } 46 | -------------------------------------------------------------------------------- /lib/mcast_set_loop.c: -------------------------------------------------------------------------------- 1 | /* include mcast_set_loop */ 2 | #include "unp.h" 3 | 4 | int 5 | mcast_set_loop(int sockfd, int onoff) 6 | { 7 | switch (sockfd_to_family(sockfd)) { 8 | case AF_INET: { 9 | u_char flag; 10 | 11 | flag = onoff; 12 | return(setsockopt(sockfd, IPPROTO_IP, IP_MULTICAST_LOOP, 13 | &flag, sizeof(flag))); 14 | } 15 | 16 | #ifdef IPV6 17 | case AF_INET6: { 18 | u_int flag; 19 | 20 | flag = onoff; 21 | return(setsockopt(sockfd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, 22 | &flag, sizeof(flag))); 23 | } 24 | #endif 25 | 26 | default: 27 | errno = EAFNOSUPPORT; 28 | return(-1); 29 | } 30 | } 31 | /* end mcast_set_loop */ 32 | 33 | void 34 | Mcast_set_loop(int sockfd, int onoff) 35 | { 36 | if (mcast_set_loop(sockfd, onoff) < 0) 37 | err_sys("mcast_set_loop error"); 38 | } 39 | -------------------------------------------------------------------------------- /lib/mcast_set_ttl.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | mcast_set_ttl(int sockfd, int val) 5 | { 6 | switch (sockfd_to_family(sockfd)) { 7 | case AF_INET: { 8 | u_char ttl; 9 | 10 | ttl = val; 11 | return(setsockopt(sockfd, IPPROTO_IP, IP_MULTICAST_TTL, 12 | &ttl, sizeof(ttl))); 13 | } 14 | 15 | #ifdef IPV6 16 | case AF_INET6: { 17 | int hop; 18 | 19 | hop = val; 20 | return(setsockopt(sockfd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, 21 | &hop, sizeof(hop))); 22 | } 23 | #endif 24 | 25 | default: 26 | errno = EAFNOSUPPORT; 27 | return(-1); 28 | } 29 | } 30 | 31 | void 32 | Mcast_set_ttl(int sockfd, int val) 33 | { 34 | if (mcast_set_ttl(sockfd, val) < 0) 35 | err_sys("mcast_set_ttl error"); 36 | } 37 | -------------------------------------------------------------------------------- /lib/my_addrs.c: -------------------------------------------------------------------------------- 1 | /* include my_addrs */ 2 | #include "unp.h" 3 | #include 4 | 5 | char ** 6 | my_addrs(int *addrtype) 7 | { 8 | struct hostent *hptr; 9 | struct utsname myname; 10 | 11 | if (uname(&myname) < 0) 12 | return(NULL); 13 | 14 | if ( (hptr = gethostbyname(myname.nodename)) == NULL) 15 | return(NULL); 16 | 17 | *addrtype = hptr->h_addrtype; 18 | return(hptr->h_addr_list); 19 | } 20 | /* end my_addrs */ 21 | 22 | char ** 23 | My_addrs(int *pfamily) 24 | { 25 | char **pptr; 26 | 27 | if ( (pptr = my_addrs(pfamily)) == NULL) 28 | err_sys("my_addrs error"); 29 | return(pptr); 30 | } 31 | -------------------------------------------------------------------------------- /lib/readable_timeo.c: -------------------------------------------------------------------------------- 1 | /* include readable_timeo */ 2 | #include "unp.h" 3 | 4 | int 5 | readable_timeo(int fd, int sec) 6 | { 7 | fd_set rset; 8 | struct timeval tv; 9 | 10 | FD_ZERO(&rset); 11 | FD_SET(fd, &rset); 12 | 13 | tv.tv_sec = sec; 14 | tv.tv_usec = 0; 15 | 16 | return(select(fd+1, &rset, NULL, NULL, &tv)); 17 | /* 4> 0 if descriptor is readable */ 18 | } 19 | /* end readable_timeo */ 20 | 21 | int 22 | Readable_timeo(int fd, int sec) 23 | { 24 | int n; 25 | 26 | if ( (n = readable_timeo(fd, sec)) < 0) 27 | err_sys("readable_timeo error"); 28 | return(n); 29 | } 30 | -------------------------------------------------------------------------------- /lib/readn.c: -------------------------------------------------------------------------------- 1 | /* include readn */ 2 | #include "unp.h" 3 | 4 | ssize_t /* Read "n" bytes from a descriptor. */ 5 | readn(int fd, void *vptr, size_t n) 6 | { 7 | size_t nleft; 8 | ssize_t nread; 9 | char *ptr; 10 | 11 | ptr = vptr; 12 | nleft = n; 13 | while (nleft > 0) { 14 | if ( (nread = read(fd, ptr, nleft)) < 0) { 15 | if (errno == EINTR) 16 | nread = 0; /* and call read() again */ 17 | else 18 | return(-1); 19 | } else if (nread == 0) 20 | break; /* EOF */ 21 | 22 | nleft -= nread; 23 | ptr += nread; 24 | } 25 | return(n - nleft); /* return >= 0 */ 26 | } 27 | /* end readn */ 28 | 29 | ssize_t 30 | Readn(int fd, void *ptr, size_t nbytes) 31 | { 32 | ssize_t n; 33 | 34 | if ( (n = readn(fd, ptr, nbytes)) < 0) 35 | err_sys("readn error"); 36 | return(n); 37 | } 38 | -------------------------------------------------------------------------------- /lib/signal.c: -------------------------------------------------------------------------------- 1 | /* include signal */ 2 | #include "unp.h" 3 | 4 | Sigfunc * 5 | signal(int signo, Sigfunc *func) 6 | { 7 | struct sigaction act, oact; 8 | 9 | act.sa_handler = func; 10 | sigemptyset(&act.sa_mask); 11 | act.sa_flags = 0; 12 | if (signo == SIGALRM) { 13 | #ifdef SA_INTERRUPT 14 | act.sa_flags |= SA_INTERRUPT; /* SunOS 4.x */ 15 | #endif 16 | } else { 17 | #ifdef SA_RESTART 18 | act.sa_flags |= SA_RESTART; /* SVR4, 44BSD */ 19 | #endif 20 | } 21 | if (sigaction(signo, &act, &oact) < 0) 22 | return(SIG_ERR); 23 | return(oact.sa_handler); 24 | } 25 | /* end signal */ 26 | 27 | Sigfunc * 28 | Signal(int signo, Sigfunc *func) /* for our signal() function */ 29 | { 30 | Sigfunc *sigfunc; 31 | 32 | if ( (sigfunc = signal(signo, func)) == SIG_ERR) 33 | err_sys("signal error"); 34 | return(sigfunc); 35 | } 36 | -------------------------------------------------------------------------------- /lib/signal_intr.c: -------------------------------------------------------------------------------- 1 | /* include signal_intr */ 2 | #include "unp.h" 3 | 4 | Sigfunc * 5 | signal_intr(int signo, Sigfunc *func) 6 | { 7 | struct sigaction act, oact; 8 | 9 | act.sa_handler = func; 10 | sigemptyset(&act.sa_mask); 11 | act.sa_flags = 0; 12 | #ifdef SA_INTERRUPT /* SunOS */ 13 | act.sa_flags |= SA_INTERRUPT; 14 | #endif 15 | if (sigaction(signo, &act, &oact) < 0) 16 | return(SIG_ERR); 17 | return(oact.sa_handler); 18 | } 19 | /* end signal_intr */ 20 | 21 | Sigfunc * 22 | Signal_intr(int signo, Sigfunc *func) 23 | { 24 | Sigfunc *sigfunc; 25 | 26 | if ( (sigfunc = signal_intr(signo, func)) == SIG_ERR) 27 | err_sys("signal_intr error"); 28 | return(sigfunc); 29 | } 30 | -------------------------------------------------------------------------------- /lib/snprintf.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Throughout the book I use snprintf() because it's safer than sprintf(). 3 | * But as of the time of this writing, not all systems provide this 4 | * function. The function below should only be built on those systems 5 | * that do not provide a real snprintf(). 6 | * The function below just acts like sprintf(); it is not safe, but it 7 | * tries to detect overflow. 8 | */ 9 | 10 | #include "unp.h" 11 | 12 | #include /* ANSI C header file */ 13 | 14 | int 15 | snprintf(char *buf, size_t size, const char *fmt, ...) 16 | { 17 | int n; 18 | va_list ap; 19 | 20 | va_start(ap, fmt); 21 | vsprintf(buf, fmt, ap); /* Sigh, some vsprintf's return ptr, not length */ 22 | n = strlen(buf); 23 | va_end(ap); 24 | if (n >= size) 25 | err_quit("snprintf: '%s' overflowed array", fmt); 26 | return(n); 27 | } 28 | -------------------------------------------------------------------------------- /lib/sock_cmp_port.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | #ifdef HAVE_SOCKADDR_DL_STRUCT 4 | #include 5 | #endif 6 | 7 | int 8 | sock_cmp_port(const struct sockaddr *sa1, const struct sockaddr *sa2, 9 | socklen_t salen) 10 | { 11 | if (sa1->sa_family != sa2->sa_family) 12 | return(-1); 13 | 14 | switch (sa1->sa_family) { 15 | case AF_INET: { 16 | return( ((struct sockaddr_in *) sa1)->sin_port == 17 | ((struct sockaddr_in *) sa2)->sin_port); 18 | } 19 | 20 | #ifdef IPV6 21 | case AF_INET6: { 22 | return( ((struct sockaddr_in6 *) sa1)->sin6_port == 23 | ((struct sockaddr_in6 *) sa2)->sin6_port); 24 | } 25 | #endif 26 | 27 | } 28 | return (-1); 29 | } 30 | -------------------------------------------------------------------------------- /lib/sock_get_port.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | sock_get_port(const struct sockaddr *sa, socklen_t salen) 5 | { 6 | switch (sa->sa_family) { 7 | case AF_INET: { 8 | struct sockaddr_in *sin = (struct sockaddr_in *) sa; 9 | 10 | return(sin->sin_port); 11 | } 12 | 13 | #ifdef IPV6 14 | case AF_INET6: { 15 | struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) sa; 16 | 17 | return(sin6->sin6_port); 18 | } 19 | #endif 20 | } 21 | 22 | return(-1); /* ??? */ 23 | } 24 | -------------------------------------------------------------------------------- /lib/sock_set_addr.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | sock_set_addr(struct sockaddr *sa, socklen_t salen, const void *addr) 5 | { 6 | switch (sa->sa_family) { 7 | case AF_INET: { 8 | struct sockaddr_in *sin = (struct sockaddr_in *) sa; 9 | 10 | memcpy(&sin->sin_addr, addr, sizeof(struct in_addr)); 11 | return; 12 | } 13 | 14 | #ifdef IPV6 15 | case AF_INET6: { 16 | struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) sa; 17 | 18 | memcpy(&sin6->sin6_addr, addr, sizeof(struct in6_addr)); 19 | return; 20 | } 21 | #endif 22 | } 23 | 24 | return; 25 | } 26 | -------------------------------------------------------------------------------- /lib/sock_set_port.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | sock_set_port(struct sockaddr *sa, socklen_t salen, int port) 5 | { 6 | switch (sa->sa_family) { 7 | case AF_INET: { 8 | struct sockaddr_in *sin = (struct sockaddr_in *) sa; 9 | 10 | sin->sin_port = port; 11 | return; 12 | } 13 | 14 | #ifdef IPV6 15 | case AF_INET6: { 16 | struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) sa; 17 | 18 | sin6->sin6_port = port; 19 | return; 20 | } 21 | #endif 22 | } 23 | 24 | return; 25 | } 26 | -------------------------------------------------------------------------------- /lib/sock_set_wild.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | sock_set_wild(struct sockaddr *sa, socklen_t salen) 5 | { 6 | const void *wildptr; 7 | 8 | switch (sa->sa_family) { 9 | case AF_INET: { 10 | static struct in_addr in4addr_any; 11 | 12 | in4addr_any.s_addr = htonl(INADDR_ANY); 13 | wildptr = &in4addr_any; 14 | break; 15 | } 16 | 17 | #ifdef IPV6 18 | case AF_INET6: { 19 | wildptr = &in6addr_any; 20 | break; 21 | } 22 | #endif 23 | 24 | default: 25 | return; 26 | } 27 | sock_set_addr(sa, salen, wildptr); 28 | return; 29 | } 30 | -------------------------------------------------------------------------------- /lib/sockatmark.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | sockatmark(int fd) 5 | { 6 | int flag; 7 | 8 | if (ioctl(fd, SIOCATMARK, &flag) < 0) 9 | return(-1); 10 | return(flag != 0); 11 | } 12 | -------------------------------------------------------------------------------- /lib/sockfd_to_family.c: -------------------------------------------------------------------------------- 1 | /* include sockfd_to_family */ 2 | #include "unp.h" 3 | 4 | int 5 | sockfd_to_family(int sockfd) 6 | { 7 | struct sockaddr_storage ss; 8 | socklen_t len; 9 | 10 | len = sizeof(ss); 11 | if (getsockname(sockfd, (SA *) &ss, &len) < 0) 12 | return(-1); 13 | return(ss.ss_family); 14 | } 15 | /* end sockfd_to_family */ 16 | 17 | int 18 | Sockfd_to_family(int sockfd) 19 | { 20 | int rc; 21 | 22 | if ( (rc = sockfd_to_family(sockfd)) < 0) 23 | err_sys("sockfd_to_family error"); 24 | 25 | return(rc); 26 | } 27 | -------------------------------------------------------------------------------- /lib/str_cli.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | str_cli(FILE *fp, int sockfd) 5 | { 6 | char sendline[MAXLINE], recvline[MAXLINE]; 7 | 8 | while (Fgets(sendline, MAXLINE, fp) != NULL) { 9 | 10 | Writen(sockfd, sendline, strlen(sendline)); 11 | 12 | if (Readline(sockfd, recvline, MAXLINE) == 0) 13 | err_quit("str_cli: server terminated prematurely"); 14 | 15 | Fputs(recvline, stdout); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /lib/str_echo.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | str_echo(int sockfd) 5 | { 6 | ssize_t n; 7 | char buf[MAXLINE]; 8 | 9 | again: 10 | while ( (n = read(sockfd, buf, MAXLINE)) > 0) 11 | Writen(sockfd, buf, n); 12 | 13 | if (n < 0 && errno == EINTR) 14 | goto again; 15 | else if (n < 0) 16 | err_sys("str_echo: read error"); 17 | } 18 | -------------------------------------------------------------------------------- /lib/tv_sub.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | tv_sub(struct timeval *out, struct timeval *in) 5 | { 6 | if ( (out->tv_usec -= in->tv_usec) < 0) { /* out -= in */ 7 | --out->tv_sec; 8 | out->tv_usec += 1000000; 9 | } 10 | out->tv_sec -= in->tv_sec; 11 | } 12 | -------------------------------------------------------------------------------- /lib/wraplib.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Wrapper functions for our own library functions. 3 | * Most are included in the source file for the function itself. 4 | */ 5 | 6 | #include "unp.h" 7 | 8 | const char * 9 | Inet_ntop(int family, const void *addrptr, char *strptr, size_t len) 10 | { 11 | const char *ptr; 12 | 13 | if (strptr == NULL) /* check for old code */ 14 | err_quit("NULL 3rd argument to inet_ntop"); 15 | if ( (ptr = inet_ntop(family, addrptr, strptr, len)) == NULL) 16 | err_sys("inet_ntop error"); /* sets errno */ 17 | return(ptr); 18 | } 19 | 20 | void 21 | Inet_pton(int family, const char *strptr, void *addrptr) 22 | { 23 | int n; 24 | 25 | if ( (n = inet_pton(family, strptr, addrptr)) < 0) 26 | err_sys("inet_pton error for %s", strptr); /* errno set */ 27 | else if (n == 0) 28 | err_quit("inet_pton error for %s", strptr); /* errno not set */ 29 | 30 | /* nothing to return */ 31 | } 32 | -------------------------------------------------------------------------------- /lib/wrapstdio.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Standard I/O wrapper functions. 3 | */ 4 | 5 | #include "unp.h" 6 | 7 | void 8 | Fclose(FILE *fp) 9 | { 10 | if (fclose(fp) != 0) 11 | err_sys("fclose error"); 12 | } 13 | 14 | FILE * 15 | Fdopen(int fd, const char *type) 16 | { 17 | FILE *fp; 18 | 19 | if ( (fp = fdopen(fd, type)) == NULL) 20 | err_sys("fdopen error"); 21 | 22 | return(fp); 23 | } 24 | 25 | char * 26 | Fgets(char *ptr, int n, FILE *stream) 27 | { 28 | char *rptr; 29 | 30 | if ( (rptr = fgets(ptr, n, stream)) == NULL && ferror(stream)) 31 | err_sys("fgets error"); 32 | 33 | return (rptr); 34 | } 35 | 36 | FILE * 37 | Fopen(const char *filename, const char *mode) 38 | { 39 | FILE *fp; 40 | 41 | if ( (fp = fopen(filename, mode)) == NULL) 42 | err_sys("fopen error"); 43 | 44 | return(fp); 45 | } 46 | 47 | void 48 | Fputs(const char *ptr, FILE *stream) 49 | { 50 | if (fputs(ptr, stream) == EOF) 51 | err_sys("fputs error"); 52 | } 53 | -------------------------------------------------------------------------------- /lib/writable_timeo.c: -------------------------------------------------------------------------------- 1 | /* include writable_timeo */ 2 | #include "unp.h" 3 | 4 | int 5 | writable_timeo(int fd, int sec) 6 | { 7 | fd_set wset; 8 | struct timeval tv; 9 | 10 | FD_ZERO(&wset); 11 | FD_SET(fd, &wset); 12 | 13 | tv.tv_sec = sec; 14 | tv.tv_usec = 0; 15 | 16 | return(select(fd+1, NULL, &wset, NULL, &tv)); 17 | /* > 0 if descriptor is writable */ 18 | } 19 | /* end writable_timeo */ 20 | 21 | int 22 | Writable_timeo(int fd, int sec) 23 | { 24 | int n; 25 | 26 | if ( (n = writable_timeo(fd, sec)) < 0) 27 | err_sys("writable_timeo error"); 28 | return(n); 29 | } 30 | -------------------------------------------------------------------------------- /lib/writen.c: -------------------------------------------------------------------------------- 1 | /* include writen */ 2 | #include "unp.h" 3 | 4 | ssize_t /* Write "n" bytes to a descriptor. */ 5 | writen(int fd, const void *vptr, size_t n) 6 | { 7 | size_t nleft; 8 | ssize_t nwritten; 9 | const char *ptr; 10 | 11 | ptr = vptr; 12 | nleft = n; 13 | while (nleft > 0) { 14 | if ( (nwritten = write(fd, ptr, nleft)) <= 0) { 15 | if (nwritten < 0 && errno == EINTR) 16 | nwritten = 0; /* and call write() again */ 17 | else 18 | return(-1); /* error */ 19 | } 20 | 21 | nleft -= nwritten; 22 | ptr += nwritten; 23 | } 24 | return(n); 25 | } 26 | /* end writen */ 27 | 28 | void 29 | Writen(int fd, void *ptr, size_t nbytes) 30 | { 31 | if (writen(fd, ptr, nbytes) != nbytes) 32 | err_sys("writen error"); 33 | } 34 | -------------------------------------------------------------------------------- /libfree/Make.tar: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | tar -cvf addrinfo.tar README.getaddrinfo addrinfo.h getaddrinfo.c \ 4 | getnameinfo.c test_addrinfo.c inet_ntop.c inet_pton.c 5 | 6 | compress addrinfo.tar 7 | -------------------------------------------------------------------------------- /libfree/Makefile: -------------------------------------------------------------------------------- 1 | include ../Make.defines 2 | 3 | all: ${LIBFREE_OBJS} 4 | ar rv ${LIBUNP_NAME} $? 5 | ${RANLIB} ${LIBUNP_NAME} 6 | 7 | test_inet_pton: test_inet_pton.o 8 | ${CC} ${CFLAGS} -o $@ test_inet_pton.o ${LIBS} 9 | 10 | clean: 11 | rm -f ${PROGS} ${CLEANFILES} 12 | -------------------------------------------------------------------------------- /libfree/README: -------------------------------------------------------------------------------- 1 | This directory contains the library files that do *not* #include unp.h. 2 | The intent is that these functions can stand alone, without the rest 3 | of the code from the book. 4 | -------------------------------------------------------------------------------- /libfree/README.getaddrinfo: -------------------------------------------------------------------------------- 1 | 09Sep96 2 | 3 | Please read the comments at the begiinning of getaddrinfo.c. 4 | 5 | Supplied with this function are the two files inet_pton.c and 6 | inet_ntop.c from the BIND-4.9.4 release. The arguments of 7 | these two functions differ from the current (but old) Internet 8 | Draft "ipngwg-bsd-api-05.txt", but the next revision of this 9 | draft will document these functions as they exist in BIND-4.9.4. 10 | 11 | Beware that most IPv6 releases are "alpha" at this time. The 12 | use of the RES_USE_INET6 option in getaddrinfo() is again from 13 | the BIND-4.9.4 release, as this is what will become the standard. 14 | But few implementations, if any, support this unless you install 15 | BIND-4.9.4 (or later) yourself. 16 | 17 | Buf fixes, suggestions, etc. are welcome. 18 | 19 | Rich Stevens (rstevens@kohala.com) 20 | -------------------------------------------------------------------------------- /libfree/in_cksum.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | uint16_t 4 | in_cksum(uint16_t *addr, int len) 5 | { 6 | int nleft = len; 7 | uint32_t sum = 0; 8 | uint16_t *w = addr; 9 | uint16_t answer = 0; 10 | 11 | /* 12 | * Our algorithm is simple, using a 32 bit accumulator (sum), we add 13 | * sequential 16 bit words to it, and at the end, fold back all the 14 | * carry bits from the top 16 bits into the lower 16 bits. 15 | */ 16 | while (nleft > 1) { 17 | sum += *w++; 18 | nleft -= 2; 19 | } 20 | 21 | /* 4mop up an odd byte, if necessary */ 22 | if (nleft == 1) { 23 | *(unsigned char *)(&answer) = *(unsigned char *)w ; 24 | sum += answer; 25 | } 26 | 27 | /* 4add back carry outs from top 16 bits to low 16 bits */ 28 | sum = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */ 29 | sum += (sum >> 16); /* add carry */ 30 | answer = ~sum; /* truncate to 16 bits */ 31 | return(answer); 32 | } 33 | -------------------------------------------------------------------------------- /libfree/inet_ntop_ipv4.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | #ifndef INET_ADDRSTRLEN 7 | #define INET_ADDRSTRLEN 16 8 | #endif 9 | 10 | /* include inet_ntop */ 11 | const char * 12 | inet_ntop(int family, const void *addrptr, char *strptr, size_t len) 13 | { 14 | const u_char *p = (const u_char *) addrptr; 15 | 16 | if (family == AF_INET) { 17 | char temp[INET_ADDRSTRLEN]; 18 | 19 | snprintf(temp, sizeof(temp), "%d.%d.%d.%d", 20 | p[0], p[1], p[2], p[3]); 21 | if (strlen(temp) >= len) { 22 | errno = ENOSPC; 23 | return (NULL); 24 | } 25 | strcpy(strptr, temp); 26 | return (strptr); 27 | } 28 | errno = EAFNOSUPPORT; 29 | return (NULL); 30 | } 31 | /* end inet_ntop */ 32 | -------------------------------------------------------------------------------- /libfree/inet_pton_ipv4.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | /* Delete following line if your system's headers already DefinE this 9 | function prototype */ 10 | int inet_aton(const char *, struct in_addr *); 11 | 12 | /* include inet_pton */ 13 | int 14 | inet_pton(int family, const char *strptr, void *addrptr) 15 | { 16 | if (family == AF_INET) { 17 | struct in_addr in_val; 18 | 19 | if (inet_aton(strptr, &in_val)) { 20 | memcpy(addrptr, &in_val, sizeof(struct in_addr)); 21 | return (1); 22 | } 23 | return(0); 24 | } 25 | errno = EAFNOSUPPORT; 26 | return (-1); 27 | } 28 | /* end inet_pton */ 29 | -------------------------------------------------------------------------------- /libfree/test_ascii2addr.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | main() 8 | { 9 | struct in6_addr foo; 10 | 11 | printf("ascii2addr returned %d\n", 12 | ascii2addr(AF_INET6, "::140.252.13.36", &foo)); 13 | 14 | exit(0); 15 | } 16 | -------------------------------------------------------------------------------- /libfree/test_getservbyname_r.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | main() 4 | { 5 | char buf[8192]; 6 | struct servent sent, *sptr; 7 | 8 | sptr = getservbyname_r("tftp", "tcp", &sent, buf, sizeof(buf)); 9 | printf("TCP, sptr = %p\n", sptr); 10 | 11 | sptr = getservbyname_r("tftp", "udp", &sent, buf, sizeof(buf)); 12 | printf("UDP, sptr = %p\n", sptr); 13 | 14 | sptr = getservbyname_r("tftp", "tcp", &sent, buf, sizeof(buf)); 15 | printf("TCP, sptr = %p\n", sptr); 16 | 17 | sptr = getservbyname_r("tftp", "udp", &sent, buf, sizeof(buf)); 18 | printf("UDP, sptr = %p\n", sptr); 19 | 20 | exit(0); 21 | } 22 | -------------------------------------------------------------------------------- /libgai/Makefile: -------------------------------------------------------------------------------- 1 | include ../Make.defines 2 | 3 | # Note: In the source code in this directory I #ifdef the constants 4 | # IPv4, IPv6 (both lowercase "v"), and UNIXdomain. This is instead of 5 | # the all-uppercase constants so that these #ifdef/#endif lines do not 6 | # appear in the book (too much clutter, given the amount of conditional 7 | # testing for all the code in this directory). 8 | 9 | all: ${LIBGAI_OBJS} 10 | ar rv ${LIBUNP_NAME} $? 11 | ${RANLIB} ${LIBUNP_NAME} 12 | 13 | PROGS = testga test1 14 | 15 | testga: testga.o 16 | ${CC} ${CFLAGS} -o $@ testga.o ${LIBS} 17 | 18 | test1: test1.o 19 | ${CC} ${CFLAGS} -o $@ test1.o ${LIBS} 20 | 21 | clean: 22 | rm -f ${PROGS} ${CLEANFILES} 23 | -------------------------------------------------------------------------------- /libgai/freeaddrinfo.c: -------------------------------------------------------------------------------- 1 | #include "gai_hdr.h" 2 | 3 | /* include freeaddrinfo */ 4 | void 5 | freeaddrinfo(struct addrinfo *aihead) 6 | { 7 | struct addrinfo *ai, *ainext; 8 | 9 | for (ai = aihead; ai != NULL; ai = ainext) { 10 | if (ai->ai_addr != NULL) 11 | free(ai->ai_addr); /* socket address structure */ 12 | 13 | if (ai->ai_canonname != NULL) 14 | free(ai->ai_canonname); 15 | 16 | ainext = ai->ai_next; /* can't fetch ai_next after free() */ 17 | free(ai); /* the addrinfo{} itself */ 18 | } 19 | } 20 | /* end freeaddrinfo */ 21 | -------------------------------------------------------------------------------- /libgai/ga_clone.c: -------------------------------------------------------------------------------- 1 | #include "gai_hdr.h" 2 | 3 | /* 4 | * Clone a new addrinfo structure from an existing one. 5 | */ 6 | 7 | /* include ga_clone */ 8 | struct addrinfo * 9 | ga_clone(struct addrinfo *ai) 10 | { 11 | struct addrinfo *new; 12 | 13 | if ( (new = calloc(1, sizeof(struct addrinfo))) == NULL) 14 | return(NULL); 15 | 16 | new->ai_next = ai->ai_next; 17 | ai->ai_next = new; 18 | 19 | new->ai_flags = 0; /* make sure AI_CLONE is off */ 20 | new->ai_family = ai->ai_family; 21 | new->ai_socktype = ai->ai_socktype; 22 | new->ai_protocol = ai->ai_protocol; 23 | new->ai_canonname = NULL; 24 | new->ai_addrlen = ai->ai_addrlen; 25 | if ( (new->ai_addr = malloc(ai->ai_addrlen)) == NULL) 26 | return(NULL); 27 | memcpy(new->ai_addr, ai->ai_addr, ai->ai_addrlen); 28 | 29 | return(new); 30 | } 31 | /* end ga_clone */ 32 | -------------------------------------------------------------------------------- /libgai/test1.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | /* 4 | * See that gethostbyname2() with an address string as the first argument 5 | * is broken in BIND-8.1-REL. 6 | * gethostbyname2("127.0.0.1", AF_INET6) -> OK! 7 | */ 8 | 9 | int 10 | main(int argc, char **argv) 11 | { 12 | struct hostent *hptr; 13 | 14 | if (argc != 2) 15 | err_quit("usage: test2 "); 16 | 17 | printf("gethostbyname2(%s, AF_INET): ", argv[1]); 18 | hptr = gethostbyname2(argv[1], AF_INET); 19 | printf("%s\n", (hptr == NULL) ? "failed" : "OK"); 20 | 21 | #ifdef IPv6 22 | printf("gethostbyname2(%s, AF_INET6): ", argv[1]); 23 | hptr = gethostbyname2(argv[1], AF_INET6); 24 | printf("%s\n", (hptr == NULL) ? "failed" : "OK"); 25 | #endif 26 | 27 | exit(0); 28 | } 29 | -------------------------------------------------------------------------------- /libroute/Makefile: -------------------------------------------------------------------------------- 1 | include ../Make.defines 2 | 3 | all: ${LIBROUTE_OBJS} 4 | ar rv ${LIBUNP_NAME} $? 5 | ${RANLIB} ${LIBUNP_NAME} 6 | 7 | clean: 8 | rm -f ${PROGS} ${CLEANFILES} 9 | -------------------------------------------------------------------------------- /libroute/get_rtaddrs.c: -------------------------------------------------------------------------------- 1 | #include "unproute.h" 2 | 3 | /* 4 | * Round up 'a' to next multiple of 'size', which must be a power of 2 5 | */ 6 | #define ROUNDUP(a, size) (((a) & ((size)-1)) ? (1 + ((a) | ((size)-1))) : (a)) 7 | 8 | /* 9 | * Step to next socket address structure; 10 | * if sa_len is 0, assume it is sizeof(u_long). 11 | */ 12 | #define NEXT_SA(ap) ap = (SA *) \ 13 | ((caddr_t) ap + (ap->sa_len ? ROUNDUP(ap->sa_len, sizeof (u_long)) : \ 14 | sizeof(u_long))) 15 | 16 | void 17 | get_rtaddrs(int addrs, SA *sa, SA **rti_info) 18 | { 19 | int i; 20 | 21 | for (i = 0; i < RTAX_MAX; i++) { 22 | if (addrs & (1 << i)) { 23 | rti_info[i] = sa; 24 | NEXT_SA(sa); 25 | } else 26 | rti_info[i] = NULL; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /libroute/net_rt_dump.c: -------------------------------------------------------------------------------- 1 | /* include net_rt_dump */ 2 | #include "unproute.h" 3 | 4 | char * 5 | net_rt_dump(int family, int flags, size_t *lenp) 6 | { 7 | int mib[6]; 8 | char *buf; 9 | 10 | mib[0] = CTL_NET; 11 | mib[1] = AF_ROUTE; 12 | mib[2] = 0; 13 | mib[3] = family; /* only addresses of this family */ 14 | mib[4] = NET_RT_DUMP; 15 | mib[5] = flags; /* not looked at with NET_RT_DUMP */ 16 | if (sysctl(mib, 6, NULL, lenp, NULL, 0) < 0) 17 | return(NULL); 18 | 19 | if ( (buf = malloc(*lenp)) == NULL) 20 | return(NULL); 21 | if (sysctl(mib, 6, buf, lenp, NULL, 0) < 0) 22 | return(NULL); 23 | 24 | return(buf); 25 | } 26 | /* end net_rt_dump */ 27 | 28 | char * 29 | Net_rt_dump(int family, int flags, size_t *lenp) 30 | { 31 | char *ptr; 32 | 33 | if ( (ptr = net_rt_dump(family, flags, lenp)) == NULL) 34 | err_sys("net_rt_dump error"); 35 | return(ptr); 36 | } 37 | -------------------------------------------------------------------------------- /libroute/net_rt_iflist.c: -------------------------------------------------------------------------------- 1 | /* include net_rt_iflist */ 2 | #include "unproute.h" 3 | 4 | char * 5 | net_rt_iflist(int family, int flags, size_t *lenp) 6 | { 7 | int mib[6]; 8 | char *buf; 9 | 10 | mib[0] = CTL_NET; 11 | mib[1] = AF_ROUTE; 12 | mib[2] = 0; 13 | mib[3] = family; /* only addresses of this family */ 14 | mib[4] = NET_RT_IFLIST; 15 | mib[5] = flags; /* interface index or 0 */ 16 | if (sysctl(mib, 6, NULL, lenp, NULL, 0) < 0) 17 | return(NULL); 18 | 19 | if ( (buf = malloc(*lenp)) == NULL) 20 | return(NULL); 21 | if (sysctl(mib, 6, buf, lenp, NULL, 0) < 0) { 22 | free(buf); 23 | return(NULL); 24 | } 25 | 26 | return(buf); 27 | } 28 | /* end net_rt_iflist */ 29 | 30 | char * 31 | Net_rt_iflist(int family, int flags, size_t *lenp) 32 | { 33 | char *ptr; 34 | 35 | if ( (ptr = net_rt_iflist(family, flags, lenp)) == NULL) 36 | err_sys("net_rt_iflist error"); 37 | return(ptr); 38 | } 39 | -------------------------------------------------------------------------------- /libroute/sock_masktop.c: -------------------------------------------------------------------------------- 1 | #include "unproute.h" 2 | 3 | const char * 4 | sock_masktop(SA *sa, socklen_t salen) 5 | { 6 | static char str[INET6_ADDRSTRLEN]; 7 | unsigned char *ptr = &sa->sa_data[2]; 8 | 9 | if (sa->sa_len == 0) 10 | return("0.0.0.0"); 11 | else if (sa->sa_len == 5) 12 | snprintf(str, sizeof(str), "%d.0.0.0", *ptr); 13 | else if (sa->sa_len == 6) 14 | snprintf(str, sizeof(str), "%d.%d.0.0", *ptr, *(ptr+1)); 15 | else if (sa->sa_len == 7) 16 | snprintf(str, sizeof(str), "%d.%d.%d.0", *ptr, *(ptr+1), *(ptr+2)); 17 | else if (sa->sa_len == 8) 18 | snprintf(str, sizeof(str), "%d.%d.%d.%d", 19 | *ptr, *(ptr+1), *(ptr+2), *(ptr+3)); 20 | else 21 | snprintf(str, sizeof(str), "(unknown mask, len = %d, family = %d)", 22 | sa->sa_len, sa->sa_family); 23 | return(str); 24 | } 25 | -------------------------------------------------------------------------------- /libroute/unproute.h: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | #include /* if_msghdr{} */ 3 | #include /* sockaddr_sdl{} */ 4 | #include /* RTA_xxx constants */ 5 | #include 6 | 7 | #ifdef HAVE_SYS_SYSCTL_H 8 | #include /* sysctl() */ 9 | #endif 10 | 11 | /* function prototypes */ 12 | void get_rtaddrs(int, struct sockaddr *, struct sockaddr **); 13 | char *net_rt_iflist(int, int, size_t *); 14 | char *net_rt_dump(int, int, size_t *); 15 | const char *sock_masktop(struct sockaddr *, socklen_t); 16 | 17 | /* wrapper functions */ 18 | char *Net_rt_iflist(int, int, size_t *); 19 | char *Net_rt_dump(int, int, size_t *); 20 | #define Sock_masktop(a,b) sock_masktop((a), (b)) 21 | -------------------------------------------------------------------------------- /mcast/Makefile: -------------------------------------------------------------------------------- 1 | include ../Make.defines 2 | 3 | PROGS = sendrecv udpcli05 udpcli06 udpserv01 4 | 5 | all: ${PROGS} 6 | 7 | sendrecv: main.o send.o recv.o 8 | ${CC} ${CFLAGS} -o $@ main.o send.o recv.o ${LIBS} 9 | 10 | # Version in book. 11 | udpcli01: udpcli01.o dgclibcast1.o 12 | ${CC} ${CFLAGS} -o $@ udpcli01.o dgclibcast1.o ${LIBS} 13 | 14 | # Correct version using sigsetjmp()/siglongjmp(). 15 | udpcli05: udpcli05.o dgclimcast5.o 16 | ${CC} ${CFLAGS} -o $@ udpcli05.o dgclimcast5.o ${LIBS} 17 | 18 | # Try to bind multicast address and send. 19 | udpcli06: udpcli06.o dgclimcast6.o 20 | ${CC} ${CFLAGS} -o $@ udpcli06.o dgclimcast6.o ${LIBS} 21 | 22 | udpserv01: udpserv01.o 23 | ${CC} ${CFLAGS} -o $@ udpserv01.o ${LIBS} 24 | 25 | clean: 26 | rm -f ${PROGS} ${CLEANFILES} 27 | -------------------------------------------------------------------------------- /mcast/main.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void recv_all(int, socklen_t); 4 | void send_all(int, SA *, socklen_t); 5 | 6 | int 7 | main(int argc, char **argv) 8 | { 9 | int sendfd, recvfd; 10 | const int on = 1; 11 | socklen_t salen; 12 | struct sockaddr *sasend, *sarecv; 13 | 14 | if (argc != 3) 15 | err_quit("usage: sendrecv "); 16 | 17 | sendfd = Udp_client(argv[1], argv[2], (void **) &sasend, &salen); 18 | 19 | recvfd = Socket(sasend->sa_family, SOCK_DGRAM, 0); 20 | 21 | Setsockopt(recvfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)); 22 | 23 | sarecv = Malloc(salen); 24 | memcpy(sarecv, sasend, salen); 25 | Bind(recvfd, sarecv, salen); 26 | 27 | Mcast_join(recvfd, sasend, salen, NULL, 0); 28 | Mcast_set_loop(sendfd, 0); 29 | 30 | if (Fork() == 0) 31 | recv_all(recvfd, salen); /* child -> receives */ 32 | 33 | send_all(sendfd, sasend, salen); /* parent -> sends */ 34 | } 35 | -------------------------------------------------------------------------------- /mcast/recv.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | recv_all(int recvfd, socklen_t salen) 5 | { 6 | int n; 7 | char line[MAXLINE+1]; 8 | socklen_t len; 9 | struct sockaddr *safrom; 10 | 11 | safrom = Malloc(salen); 12 | 13 | for ( ; ; ) { 14 | len = salen; 15 | n = Recvfrom(recvfd, line, MAXLINE, 0, safrom, &len); 16 | 17 | line[n] = 0; /* null terminate */ 18 | printf("from %s: %s", Sock_ntop(safrom, len), line); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /mcast/send.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | #include 3 | 4 | #define SENDRATE 5 /* send one datagram every five seconds */ 5 | 6 | void 7 | send_all(int sendfd, SA *sadest, socklen_t salen) 8 | { 9 | char line[MAXLINE]; /* hostname and process ID */ 10 | struct utsname myname; 11 | 12 | if (uname(&myname) < 0) 13 | err_sys("uname error");; 14 | snprintf(line, sizeof(line), "%s, %d\n", myname.nodename, getpid()); 15 | 16 | for ( ; ; ) { 17 | Sendto(sendfd, line, strlen(line), 0, sadest, salen); 18 | 19 | sleep(SENDRATE); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /mcast/udpcli01.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: udpcli01 "); 11 | 12 | bzero(&servaddr, sizeof(servaddr)); 13 | servaddr.sin_family = AF_INET; 14 | servaddr.sin_port = htons(SERV_PORT); 15 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 16 | 17 | sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 18 | 19 | dg_cli(stdin, sockfd, (SA *) &servaddr, sizeof(servaddr)); 20 | 21 | exit(0); 22 | } 23 | -------------------------------------------------------------------------------- /mcast/udpcli05.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: udpcli05 "); 11 | 12 | bzero(&servaddr, sizeof(servaddr)); 13 | servaddr.sin_family = AF_INET; 14 | servaddr.sin_port = htons(13); /* standard daytime server */ 15 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 16 | 17 | sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 18 | 19 | dg_cli(stdin, sockfd, (SA *) &servaddr, sizeof(servaddr)); 20 | 21 | exit(0); 22 | } 23 | -------------------------------------------------------------------------------- /mcast/udpcli06.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | socklen_t salen; 8 | struct sockaddr *cli, *serv; 9 | 10 | if (argc != 2) 11 | err_quit("usage: udpcli06 "); 12 | 13 | sockfd = Udp_client(argv[1], "daytime", (void **) &serv, &salen); 14 | 15 | cli = Malloc(salen); 16 | memcpy(cli, serv, salen); /* copy socket address struct */ 17 | sock_set_port(cli, salen, 0); /* and set port to 0 */ 18 | Bind(sockfd, cli, salen); 19 | 20 | dg_cli(stdin, sockfd, serv, salen); 21 | 22 | exit(0); 23 | } 24 | -------------------------------------------------------------------------------- /mcast/udpserv01.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr, grpaddr, cliaddr; 8 | 9 | sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 10 | 11 | bzero(&servaddr, sizeof(servaddr)); 12 | servaddr.sin_family = AF_INET; 13 | servaddr.sin_addr.s_addr = htonl(INADDR_ANY); 14 | servaddr.sin_port = htons(SERV_PORT); 15 | 16 | Bind(sockfd, (SA *) &servaddr, sizeof(servaddr)); 17 | 18 | bzero(&grpaddr, sizeof(servaddr)); 19 | grpaddr.sin_family = AF_INET; 20 | grpaddr.sin_addr.s_addr = inet_addr("224.0.0.1"); 21 | 22 | mcast_join(sockfd, &grpaddr, sizeof(grpaddr), NULL, 0); 23 | 24 | dg_echo(sockfd, (SA *) &cliaddr, sizeof(cliaddr)); 25 | } 26 | -------------------------------------------------------------------------------- /mysdr/Makefile: -------------------------------------------------------------------------------- 1 | include ../Make.defines 2 | 3 | PROGS = mysdr 4 | 5 | all: ${PROGS} 6 | 7 | mysdr: main.o loop.o 8 | ${CC} ${CFLAGS} -o $@ main.o loop.o ${LIBS} 9 | 10 | clean: 11 | rm -f ${PROGS} ${CLEANFILES} 12 | -------------------------------------------------------------------------------- /mysdr/main.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | #define SAP_NAME "sap.mcast.net" /* default group name and port */ 4 | #define SAP_PORT "9875" 5 | 6 | void loop(int, socklen_t); 7 | 8 | int 9 | main(int argc, char **argv) 10 | { 11 | int sockfd; 12 | const int on = 1; 13 | socklen_t salen; 14 | struct sockaddr *sa; 15 | 16 | if (argc == 1) 17 | sockfd = Udp_client(SAP_NAME, SAP_PORT, (void **) &sa, &salen); 18 | else if (argc == 4) 19 | sockfd = Udp_client(argv[1], argv[2], (void **) &sa, &salen); 20 | else 21 | err_quit("usage: mysdr "); 22 | 23 | Setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)); 24 | Bind(sockfd, sa, salen); 25 | 26 | Mcast_join(sockfd, sa, salen, (argc == 4) ? argv[3] : NULL, 0); 27 | 28 | loop(sockfd, salen); /* receive and print */ 29 | 30 | exit(0); 31 | } 32 | -------------------------------------------------------------------------------- /mysdr/mysdr.h: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | #define SAP_VERSION 1 4 | #define SAP_VERSION_MASK 0xe0000000 5 | #define SAP_VERSION_SHIFT 29 6 | #define SAP_IPV6 0x10000000 7 | #define SAP_DELETE 0x04000000 8 | #define SAP_ENCRYPTED 0x02000000 9 | #define SAP_COMPRESSED 0x01000000 10 | #define SAP_AUTHLEN_MASK 0x00ff0000 11 | #define SAP_AUTHLEN_SHIFT 16 12 | #define SAP_HASH_MASK 0x0000ffff 13 | -------------------------------------------------------------------------------- /names/daytimetcpcli.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd, n; 7 | char recvline[MAXLINE + 1]; 8 | socklen_t len; 9 | struct sockaddr_storage ss; 10 | 11 | if (argc != 3) 12 | err_quit("usage: daytimetcpcli "); 13 | 14 | sockfd = Tcp_connect(argv[1], argv[2]); 15 | 16 | len = sizeof(ss); 17 | Getpeername(sockfd, (SA *)&ss, &len); 18 | printf("connected to %s\n", Sock_ntop_host((SA *)&ss, len)); 19 | 20 | while ( (n = Read(sockfd, recvline, MAXLINE)) > 0) { 21 | recvline[n] = 0; /* null terminate */ 22 | Fputs(recvline, stdout); 23 | } 24 | exit(0); 25 | } 26 | -------------------------------------------------------------------------------- /names/daytimetcpsrv1.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | #include 3 | 4 | int 5 | main(int argc, char **argv) 6 | { 7 | int listenfd, connfd; 8 | socklen_t len; 9 | char buff[MAXLINE]; 10 | time_t ticks; 11 | struct sockaddr_storage cliaddr; 12 | 13 | if (argc != 2) 14 | err_quit("usage: daytimetcpsrv1 "); 15 | 16 | listenfd = Tcp_listen(NULL, argv[1], NULL); 17 | 18 | for ( ; ; ) { 19 | len = sizeof(cliaddr); 20 | connfd = Accept(listenfd, (SA *)&cliaddr, &len); 21 | printf("connection from %s\n", Sock_ntop((SA *)&cliaddr, len)); 22 | 23 | ticks = time(NULL); 24 | snprintf(buff, sizeof(buff), "%.24s\r\n", ctime(&ticks)); 25 | Write(connfd, buff, strlen(buff)); 26 | 27 | Close(connfd); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /names/daytimetcpsrv2.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | #include 3 | 4 | int 5 | main(int argc, char **argv) 6 | { 7 | int listenfd, connfd; 8 | socklen_t len, addrlen; 9 | char buff[MAXLINE]; 10 | time_t ticks; 11 | struct sockaddr_storage cliaddr; 12 | 13 | if (argc == 2) 14 | listenfd = Tcp_listen(NULL, argv[1], &addrlen); 15 | else if (argc == 3) 16 | listenfd = Tcp_listen(argv[1], argv[2], &addrlen); 17 | else 18 | err_quit("usage: daytimetcpsrv2 [ ] "); 19 | 20 | for ( ; ; ) { 21 | len = sizeof(cliaddr); 22 | connfd = Accept(listenfd, (SA *)&cliaddr, &len); 23 | printf("connection from %s\n", Sock_ntop((SA *)&cliaddr, len)); 24 | 25 | ticks = time(NULL); 26 | snprintf(buff, sizeof(buff), "%.24s\r\n", ctime(&ticks)); 27 | Write(connfd, buff, strlen(buff)); 28 | 29 | Close(connfd); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /names/daytimeudpcli1.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd, n; 7 | char recvline[MAXLINE + 1]; 8 | socklen_t salen; 9 | struct sockaddr *sa; 10 | 11 | if (argc != 3) 12 | err_quit("usage: daytimeudpcli1 "); 13 | 14 | sockfd = Udp_client(argv[1], argv[2], (void **) &sa, &salen); 15 | 16 | printf("sending to %s\n", Sock_ntop_host(sa, salen)); 17 | 18 | Sendto(sockfd, "", 1, 0, sa, salen); /* send 1-byte datagram */ 19 | 20 | n = Recvfrom(sockfd, recvline, MAXLINE, 0, NULL, NULL); 21 | recvline[n] = '\0'; /* null terminate */ 22 | Fputs(recvline, stdout); 23 | 24 | exit(0); 25 | } 26 | -------------------------------------------------------------------------------- /names/daytimeudpcli2.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd, n; 7 | char recvline[MAXLINE + 1]; 8 | 9 | if (argc != 3) 10 | err_quit("usage: daytimeudpcli2 "); 11 | 12 | sockfd = Udp_connect(argv[1], argv[2]); 13 | 14 | Write(sockfd, "", 1); /* send 1-byte datagram */ 15 | 16 | n = Read(sockfd, recvline, MAXLINE); 17 | recvline[n] = '\0'; /* null terminate */ 18 | Fputs(recvline, stdout); 19 | 20 | exit(0); 21 | } 22 | -------------------------------------------------------------------------------- /names/daytimeudpsrv2.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | #include 3 | 4 | int 5 | main(int argc, char **argv) 6 | { 7 | int sockfd; 8 | ssize_t n; 9 | char buff[MAXLINE]; 10 | time_t ticks; 11 | socklen_t len; 12 | struct sockaddr_storage cliaddr; 13 | 14 | if (argc == 2) 15 | sockfd = Udp_server(NULL, argv[1], NULL); 16 | else if (argc == 3) 17 | sockfd = Udp_server(argv[1], argv[2], NULL); 18 | else 19 | err_quit("usage: daytimeudpsrv [ ] "); 20 | 21 | for ( ; ; ) { 22 | len = sizeof(cliaddr); 23 | n = Recvfrom(sockfd, buff, MAXLINE, 0, (SA *)&cliaddr, &len); 24 | printf("datagram from %s\n", Sock_ntop((SA *)&cliaddr, len)); 25 | 26 | ticks = time(NULL); 27 | snprintf(buff, sizeof(buff), "%.24s\r\n", ctime(&ticks)); 28 | Sendto(sockfd, buff, strlen(buff), 0, (SA *)&cliaddr, len); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /names/daytimeudpsrv3.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | #include 3 | 4 | int 5 | main(int argc, char **argv) 6 | { 7 | int sockfd; 8 | ssize_t n; 9 | char buff[MAXLINE]; 10 | time_t ticks; 11 | socklen_t len; 12 | struct sockaddr_storage cliaddr; 13 | 14 | if (argc == 2) 15 | sockfd = Udp_server_reuseaddr(NULL, argv[1], NULL); 16 | else if (argc == 3) 17 | sockfd = Udp_server_reuseaddr(argv[1], argv[2], NULL); 18 | else 19 | err_quit("usage: daytimeudpsrv [ ] "); 20 | 21 | for ( ; ; ) { 22 | len = sizeof(cliaddr); 23 | n = Recvfrom(sockfd, buff, MAXLINE, 0, (SA *)&cliaddr, &len); 24 | printf("datagram from %s\n", Sock_ntop((SA *)&cliaddr, len)); 25 | 26 | ticks = time(NULL); 27 | snprintf(buff, sizeof(buff), "%.24s\r\n", ctime(&ticks)); 28 | Sendto(sockfd, buff, strlen(buff), 0, (SA *)&cliaddr, len); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /names/hostent.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | char *ptr, **pptr; 7 | char str[INET_ADDRSTRLEN]; 8 | struct hostent *hptr; 9 | 10 | while (--argc > 0) { 11 | ptr = *++argv; 12 | if ( (hptr = gethostbyname(ptr)) == NULL) { 13 | err_msg("gethostbyname error for host: %s: %s", 14 | ptr, hstrerror(h_errno)); 15 | continue; 16 | } 17 | printf("official hostname: %s\n", hptr->h_name); 18 | 19 | for (pptr = hptr->h_aliases; *pptr != NULL; pptr++) 20 | printf("\talias: %s\n", *pptr); 21 | 22 | switch (hptr->h_addrtype) { 23 | case AF_INET: 24 | pptr = hptr->h_addr_list; 25 | for ( ; *pptr != NULL; pptr++) 26 | printf("\taddress: %s\n", 27 | Inet_ntop(hptr->h_addrtype, *pptr, str, sizeof(str))); 28 | break; 29 | 30 | default: 31 | err_ret("unknown address type"); 32 | break; 33 | } 34 | } 35 | exit(0); 36 | } 37 | -------------------------------------------------------------------------------- /names/myaddrs1.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | #include 3 | 4 | char ** 5 | my_addrs(int *addrtype) 6 | { 7 | struct hostent *hptr; 8 | char myname[MAXHOSTNAMELEN]; 9 | 10 | if (gethostname(myname, sizeof(myname)) < 0) 11 | return(NULL); 12 | 13 | if ( (hptr = gethostbyname(myname)) == NULL) 14 | return(NULL); 15 | 16 | *addrtype = hptr->h_addrtype; 17 | return(hptr->h_addr_list); 18 | } 19 | -------------------------------------------------------------------------------- /names/netent.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | char *ptr, **pptr; 7 | struct netent *nptr; 8 | 9 | while (--argc > 0) { 10 | ptr = *++argv; 11 | if ( (nptr = getnetbyname(ptr)) == NULL) { 12 | err_msg("getnetbyname error for net: %s: %s", 13 | ptr, hstrerror(h_errno)); 14 | continue; 15 | } 16 | printf("official netname: %s\n", nptr->n_name); 17 | 18 | for (pptr = nptr->n_aliases; *pptr != NULL; pptr++) 19 | printf(" alias: %s\n", *pptr); 20 | 21 | switch (nptr->n_addrtype) { 22 | case AF_INET: 23 | #ifdef AF_INET6 24 | case AF_INET6: 25 | #endif 26 | break; 27 | 28 | default: 29 | err_ret("unknown address type"); 30 | break; 31 | } 32 | } 33 | exit(0); 34 | } 35 | -------------------------------------------------------------------------------- /names/prmyaddrs.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | char **my_addrs(int *); 4 | 5 | int 6 | main(int argc, char **argv) 7 | { 8 | int addrtype; 9 | char **pptr, buf[INET6_ADDRSTRLEN]; 10 | 11 | if ( (pptr = my_addrs(&addrtype)) == NULL) 12 | err_quit("my_addrs error"); 13 | 14 | for ( ; *pptr != NULL; pptr++) 15 | printf("\taddress: %s\n", 16 | Inet_ntop(addrtype, *pptr, buf, sizeof(buf))); 17 | 18 | exit(0); 19 | } 20 | -------------------------------------------------------------------------------- /names/prmyaddrs1.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | char **my_addrs(int *); 4 | 5 | int 6 | main(int argc, char **argv) 7 | { 8 | int addrtype; 9 | char **pptr, buf[INET6_ADDRSTRLEN]; 10 | 11 | if ( (pptr = my_addrs(&addrtype)) == NULL) 12 | err_quit("my_addrs error"); 13 | 14 | for ( ; *pptr != NULL; pptr++) 15 | printf("\taddress: %s\n", 16 | Inet_ntop(addrtype, *pptr, buf, sizeof(buf))); 17 | 18 | exit(0); 19 | } 20 | -------------------------------------------------------------------------------- /names/test2.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd, n; 7 | char recvline[MAXLINE + 1]; 8 | socklen_t salen; 9 | struct sockaddr *sa, *sabind; 10 | 11 | if (argc != 3) 12 | err_quit("usage: test2 "); 13 | 14 | sockfd = Udp_client(argv[1], argv[2], (void **) &sa, &salen); 15 | 16 | /* Same as daytimeudpcli1, but we explicitly bind the wildcard */ 17 | sabind = Malloc(salen); 18 | bzero(sabind, salen); 19 | sabind->sa_family = sa->sa_family; 20 | Bind(sockfd, sabind, salen); 21 | printf("bound %s\n", Sock_ntop(sabind, salen)); 22 | 23 | printf("sending to %s\n", Sock_ntop_host(sa, salen)); 24 | 25 | Sendto(sockfd, "", 1, 0, sa, salen); /* send 1-byte datagram */ 26 | 27 | n = Recvfrom(sockfd, recvline, MAXLINE, 0, NULL, NULL); 28 | recvline[n] = 0; /* null terminate */ 29 | Fputs(recvline, stdout); 30 | 31 | exit(0); 32 | } 33 | -------------------------------------------------------------------------------- /nonblock/Makefile: -------------------------------------------------------------------------------- 1 | include ../Make.defines 2 | 3 | PROGS = daytimetcpcli tcpcli01 tcpcli02 tcpcli03 tcpcli04 tcpservselect02 web 4 | 5 | all: ${PROGS} 6 | 7 | daytimetcpcli: daytimetcpcli.o 8 | ${CC} ${CFLAGS} -o $@ daytimetcpcli.o ${LIBS} 9 | 10 | tcpcli01: tcpcli01.o strclifork.o 11 | ${CC} ${CFLAGS} -o $@ tcpcli01.o strclifork.o ${LIBS} 12 | 13 | tcpcli02: tcpcli02.o strclinonb.o 14 | ${CC} ${CFLAGS} -o $@ tcpcli02.o strclinonb.o ${LIBS} 15 | 16 | tcpcli03: tcpcli03.o 17 | ${CC} ${CFLAGS} -o $@ tcpcli03.o ${LIBS} 18 | 19 | tcpcli04: tcpcli04.o 20 | ${CC} ${CFLAGS} -o $@ tcpcli04.o ${LIBS} 21 | 22 | tcpservselect03: tcpservselect03.o 23 | ${CC} ${CFLAGS} -o $@ tcpservselect03.o ${LIBS} 24 | 25 | web: web.o home_page.o start_connect.o write_get_cmd.o 26 | ${CC} ${CFLAGS} -o $@ web.o home_page.o start_connect.o \ 27 | write_get_cmd.o ${LIBS} 28 | 29 | clean: 30 | rm -f ${PROGS} ${CLEANFILES} 31 | -------------------------------------------------------------------------------- /nonblock/daytimetcpcli.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd, n; 7 | struct sockaddr_in servaddr; 8 | char recvline[MAXLINE + 1]; 9 | 10 | if ( (sockfd = socket(PF_INET, SOCK_STREAM, 0)) < 0) 11 | err_sys("socket error"); 12 | 13 | bzero(&servaddr, sizeof(servaddr)); 14 | servaddr.sin_family = AF_INET; 15 | servaddr.sin_addr.s_addr = inet_addr(argv[1]); 16 | servaddr.sin_port = htons(13); /* daytime server */ 17 | 18 | if (connect_nonb(sockfd, (SA *) &servaddr, sizeof(servaddr), 0) < 0) 19 | err_sys("connect error"); 20 | 21 | for ( ; ; ) { 22 | if ( (n = read(sockfd, recvline, MAXLINE)) <= 0) { 23 | if (n == 0) 24 | break; /* server closed connection */ 25 | else 26 | err_sys("read error"); 27 | } 28 | recvline[n] = 0; /* null terminate */ 29 | Fputs(recvline, stdout); 30 | } 31 | exit(0); 32 | } 33 | -------------------------------------------------------------------------------- /nonblock/doit.1: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | case $# in 4 | 1) break ;; 5 | *) echo "one argument (#simultaneous connections) required" 1>&2 6 | exit 1 ;; 7 | esac 8 | 9 | time ./web $1 192.207.117.2 / \ 10 | /img/logo/awl_logo_blue_50x40.gif \ 11 | /img/a_world_of_learning.gif \ 12 | /img/toolbar_soptions.gif \ 13 | /img/toolbar_purchase.gif \ 14 | /img/toolbar_feedback.gif \ 15 | /img/toolbar_top_hilite.gif \ 16 | /img/toolbar_qsearch.gif \ 17 | /img/blue_dot.gif \ 18 | /img/logo/pearson_logo_50.gif 19 | -------------------------------------------------------------------------------- /nonblock/home_page.c: -------------------------------------------------------------------------------- 1 | #include "web.h" 2 | 3 | void 4 | home_page(const char *host, const char *fname) 5 | { 6 | int fd, n; 7 | char line[MAXLINE]; 8 | 9 | fd = Tcp_connect(host, SERV); /* blocking connect() */ 10 | 11 | n = snprintf(line, sizeof(line), GET_CMD, fname); 12 | Writen(fd, line, n); 13 | 14 | for ( ; ; ) { 15 | if ( (n = Read(fd, line, MAXLINE)) == 0) 16 | break; /* server closed connection */ 17 | 18 | printf("read %d bytes of home page\n", n); 19 | /* do whatever with data */ 20 | } 21 | printf("end-of-file on home page\n"); 22 | Close(fd); 23 | } 24 | -------------------------------------------------------------------------------- /nonblock/strclifork.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | str_cli(FILE *fp, int sockfd) 5 | { 6 | pid_t pid; 7 | char sendline[MAXLINE], recvline[MAXLINE]; 8 | 9 | if ( (pid = Fork()) == 0) { /* child: server -> stdout */ 10 | while (Readline(sockfd, recvline, MAXLINE) > 0) 11 | Fputs(recvline, stdout); 12 | 13 | kill(getppid(), SIGTERM); /* in case parent still running */ 14 | exit(0); 15 | } 16 | 17 | /* parent: stdin -> server */ 18 | while (Fgets(sendline, MAXLINE, fp) != NULL) 19 | Writen(sockfd, sendline, strlen(sendline)); 20 | 21 | Shutdown(sockfd, SHUT_WR); /* EOF on stdin, send FIN */ 22 | pause(); 23 | return; 24 | } 25 | -------------------------------------------------------------------------------- /nonblock/tcpcli01.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: tcpcli "); 11 | 12 | sockfd = Socket(AF_INET, SOCK_STREAM, 0); 13 | 14 | bzero(&servaddr, sizeof(servaddr)); 15 | servaddr.sin_family = AF_INET; 16 | servaddr.sin_port = htons(7); 17 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 18 | 19 | Connect(sockfd, (SA *) &servaddr, sizeof(servaddr)); 20 | 21 | str_cli(stdin, sockfd); /* do it all */ 22 | 23 | exit(0); 24 | } 25 | -------------------------------------------------------------------------------- /nonblock/tcpcli02.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: tcpcli "); 11 | 12 | sockfd = Socket(AF_INET, SOCK_STREAM, 0); 13 | 14 | bzero(&servaddr, sizeof(servaddr)); 15 | servaddr.sin_family = AF_INET; 16 | servaddr.sin_port = htons(7); 17 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 18 | 19 | Connect(sockfd, (SA *) &servaddr, sizeof(servaddr)); 20 | 21 | str_cli(stdin, sockfd); /* do it all */ 22 | 23 | exit(0); 24 | } 25 | -------------------------------------------------------------------------------- /nonblock/tcpcli03.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct linger ling; 8 | struct sockaddr_in servaddr; 9 | 10 | if (argc != 2) 11 | err_quit("usage: tcpcli "); 12 | 13 | sockfd = Socket(AF_INET, SOCK_STREAM, 0); 14 | 15 | bzero(&servaddr, sizeof(servaddr)); 16 | servaddr.sin_family = AF_INET; 17 | servaddr.sin_port = htons(SERV_PORT); 18 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 19 | 20 | Connect(sockfd, (SA *) &servaddr, sizeof(servaddr)); 21 | 22 | ling.l_onoff = 1; /* cause RST to be sent on close() */ 23 | ling.l_linger = 0; 24 | Setsockopt(sockfd, SOL_SOCKET, SO_LINGER, &ling, sizeof(ling)); 25 | Close(sockfd); 26 | 27 | exit(0); 28 | } 29 | -------------------------------------------------------------------------------- /nonblock/tcpcli04.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct linger ling; 8 | struct sockaddr_in servaddr; 9 | 10 | if (argc != 2) 11 | err_quit("usage: tcpcli "); 12 | 13 | sockfd = Socket(AF_INET, SOCK_STREAM, 0); 14 | 15 | bzero(&servaddr, sizeof(servaddr)); 16 | servaddr.sin_family = AF_INET; 17 | servaddr.sin_port = htons(SERV_PORT); 18 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 19 | 20 | Connect(sockfd, (SA *) &servaddr, sizeof(servaddr)); 21 | 22 | ling.l_onoff = 1; /* cause RST to be sent on close() */ 23 | ling.l_linger = 0; 24 | Setsockopt(sockfd, SOL_SOCKET, SO_LINGER, &ling, sizeof(ling)); 25 | 26 | str_cli(stdin, sockfd); /* do it all */ 27 | 28 | exit(0); 29 | } 30 | -------------------------------------------------------------------------------- /nonblock/web.h: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | #define MAXFILES 20 4 | #define SERV "80" /* port number or service name */ 5 | 6 | struct file { 7 | char *f_name; /* filename */ 8 | char *f_host; /* hostname or IPv4/IPv6 address */ 9 | int f_fd; /* descriptor */ 10 | int f_flags; /* F_xxx below */ 11 | } file[MAXFILES]; 12 | 13 | #define F_CONNECTING 1 /* connect() in progress */ 14 | #define F_READING 2 /* connect() complete; now reading */ 15 | #define F_DONE 4 /* all done */ 16 | 17 | #define GET_CMD "GET %s HTTP/1.0\r\n\r\n" 18 | 19 | /* globals */ 20 | int nconn, nfiles, nlefttoconn, nlefttoread, maxfd; 21 | fd_set rset, wset; 22 | 23 | /* function prototypes */ 24 | void home_page(const char *, const char *); 25 | void start_connect(struct file *); 26 | void write_get_cmd(struct file *); 27 | -------------------------------------------------------------------------------- /nonblock/write_get_cmd.c: -------------------------------------------------------------------------------- 1 | #include "web.h" 2 | 3 | void 4 | write_get_cmd(struct file *fptr) 5 | { 6 | int n; 7 | char line[MAXLINE]; 8 | 9 | n = snprintf(line, sizeof(line), GET_CMD, fptr->f_name); 10 | Writen(fptr->f_fd, line, n); 11 | printf("wrote %d bytes for %s\n", n, fptr->f_name); 12 | 13 | fptr->f_flags = F_READING; /* clears F_CONNECTING */ 14 | 15 | FD_SET(fptr->f_fd, &rset); /* will read server's reply */ 16 | if (fptr->f_fd > maxfd) 17 | maxfd = fptr->f_fd; 18 | } 19 | -------------------------------------------------------------------------------- /oob/sigchldwaitpid.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | sig_chld(int signo) 5 | { 6 | pid_t pid; 7 | int stat; 8 | 9 | while ( (pid = waitpid(-1, &stat, WNOHANG)) > 0) { 10 | printf("child %d terminated\n", pid); 11 | } 12 | return; 13 | } 14 | -------------------------------------------------------------------------------- /oob/strecho02.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | str_echo(int sockfd) 5 | { 6 | ssize_t n; 7 | char line[MAXLINE]; 8 | 9 | heartbeat_serv(sockfd, 1, 5); 10 | 11 | for ( ; ; ) { 12 | if ( (n = Readline(sockfd, line, MAXLINE)) == 0) 13 | return; /* connection closed by other end */ 14 | 15 | Writen(sockfd, line, n); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /oob/tcpcli02.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: tcpcli "); 11 | 12 | sockfd = Socket(AF_INET, SOCK_STREAM, 0); 13 | 14 | bzero(&servaddr, sizeof(servaddr)); 15 | servaddr.sin_family = AF_INET; 16 | servaddr.sin_port = htons(SERV_PORT); 17 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 18 | 19 | Connect(sockfd, (SA *) &servaddr, sizeof(servaddr)); 20 | 21 | str_cli(stdin, sockfd); /* do it all */ 22 | 23 | exit(0); 24 | } 25 | -------------------------------------------------------------------------------- /oob/tcprecv04.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int listenfd, connfd, n, on=1; 7 | char buff[100]; 8 | 9 | if (argc == 2) 10 | listenfd = Tcp_listen(NULL, argv[1], NULL); 11 | else if (argc == 3) 12 | listenfd = Tcp_listen(argv[1], argv[2], NULL); 13 | else 14 | err_quit("usage: tcprecv04 [ ] "); 15 | 16 | Setsockopt(listenfd, SOL_SOCKET, SO_OOBINLINE, &on, sizeof(on)); 17 | 18 | connfd = Accept(listenfd, NULL, NULL); 19 | sleep(5); 20 | 21 | for ( ; ; ) { 22 | if (Sockatmark(connfd)) 23 | printf("at OOB mark\n"); 24 | 25 | if ( (n = Read(connfd, buff, sizeof(buff)-1)) == 0) { 26 | printf("received EOF\n"); 27 | exit(0); 28 | } 29 | buff[n] = 0; /* null terminate */ 30 | printf("read %d bytes: %s\n", n, buff); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /oob/tcprecv05.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int listenfd, connfd; 4 | 5 | void sig_urg(int); 6 | 7 | int 8 | main(int argc, char **argv) 9 | { 10 | int size; 11 | 12 | if (argc == 2) 13 | listenfd = Tcp_listen(NULL, argv[1], NULL); 14 | else if (argc == 3) 15 | listenfd = Tcp_listen(argv[1], argv[2], NULL); 16 | else 17 | err_quit("usage: tcprecv05 [ ] "); 18 | 19 | size = 4096; 20 | Setsockopt(listenfd, SOL_SOCKET, SO_RCVBUF, &size, sizeof(size)); 21 | 22 | connfd = Accept(listenfd, NULL, NULL); 23 | 24 | Signal(SIGURG, sig_urg); 25 | Fcntl(connfd, F_SETOWN, getpid()); 26 | 27 | for ( ; ; ) 28 | pause(); 29 | } 30 | 31 | void 32 | sig_urg(int signo) 33 | { 34 | int n; 35 | char buff[2048]; 36 | 37 | printf("SIGURG received\n"); 38 | n = Recv(connfd, buff, sizeof(buff)-1, MSG_OOB); 39 | buff[n] = 0; /* null terminate */ 40 | printf("read %d OOB byte\n", n); 41 | } 42 | -------------------------------------------------------------------------------- /oob/tcprecv06.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int listenfd, connfd, n, on=1; 7 | char buff[100]; 8 | 9 | if (argc == 2) 10 | listenfd = Tcp_listen(NULL, argv[1], NULL); 11 | else if (argc == 3) 12 | listenfd = Tcp_listen(argv[1], argv[2], NULL); 13 | else 14 | err_quit("usage: tcprecv06 [ ] "); 15 | 16 | Setsockopt(listenfd, SOL_SOCKET, SO_OOBINLINE, &on, sizeof(on)); 17 | 18 | connfd = Accept(listenfd, NULL, NULL); 19 | sleep(5); 20 | 21 | for ( ; ; ) { 22 | if (Sockatmark(connfd)) 23 | printf("at OOB mark\n"); 24 | 25 | if ( (n = Read(connfd, buff, sizeof(buff)-1)) == 0) { 26 | printf("received EOF\n"); 27 | exit(0); 28 | } 29 | buff[n] = 0; /* null terminate */ 30 | printf("read %d bytes: %s\n", n, buff); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /oob/tcpsend01.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | 8 | if (argc != 3) 9 | err_quit("usage: tcpsend01 "); 10 | 11 | sockfd = Tcp_connect(argv[1], argv[2]); 12 | 13 | Write(sockfd, "123", 3); 14 | printf("wrote 3 bytes of normal data\n"); 15 | sleep(1); 16 | 17 | Send(sockfd, "4", 1, MSG_OOB); 18 | printf("wrote 1 byte of OOB data\n"); 19 | sleep(1); 20 | 21 | Write(sockfd, "56", 2); 22 | printf("wrote 2 bytes of normal data\n"); 23 | sleep(1); 24 | 25 | Send(sockfd, "7", 1, MSG_OOB); 26 | printf("wrote 1 byte of OOB data\n"); 27 | sleep(1); 28 | 29 | Write(sockfd, "89", 2); 30 | printf("wrote 2 bytes of normal data\n"); 31 | sleep(1); 32 | 33 | exit(0); 34 | } 35 | -------------------------------------------------------------------------------- /oob/tcpsend02.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | 8 | if (argc != 3) 9 | err_quit("usage: tcpsend02 "); 10 | 11 | sockfd = Tcp_connect(argv[1], argv[2]); 12 | 13 | Write(sockfd, "123", 3); 14 | printf("wrote 3 bytes of normal data\n"); 15 | sleep(1); 16 | 17 | Send(sockfd, "4", 1, MSG_OOB); 18 | printf("wrote 1 byte of OOB data\n"); 19 | sleep(1); 20 | 21 | Write(sockfd, "56", 2); 22 | printf("wrote 2 bytes of normal data\n"); 23 | sleep(1); 24 | 25 | Send(sockfd, "7", 1, MSG_OOB); 26 | printf("wrote 1 byte of OOB data\n"); 27 | sleep(1); 28 | 29 | Write(sockfd, "89", 2); 30 | printf("wrote 2 bytes of normal data\n"); 31 | sleep(1); 32 | 33 | exit(0); 34 | } 35 | -------------------------------------------------------------------------------- /oob/tcpsend03.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | 8 | if (argc != 3) 9 | err_quit("usage: tcpsend03 "); 10 | 11 | sockfd = Tcp_connect(argv[1], argv[2]); 12 | 13 | Write(sockfd, "123", 3); 14 | printf("wrote 3 bytes of normal data\n"); 15 | sleep(1); 16 | 17 | Send(sockfd, "4", 1, MSG_OOB); 18 | printf("wrote 1 byte of OOB data\n"); 19 | sleep(1); 20 | 21 | Write(sockfd, "56", 2); 22 | printf("wrote 2 bytes of normal data\n"); 23 | sleep(1); 24 | 25 | Send(sockfd, "7", 1, MSG_OOB); 26 | printf("wrote 1 byte of OOB data\n"); 27 | sleep(1); 28 | 29 | Write(sockfd, "89", 2); 30 | printf("wrote 2 bytes of normal data\n"); 31 | sleep(1); 32 | 33 | exit(0); 34 | } 35 | -------------------------------------------------------------------------------- /oob/tcpsend04.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | 8 | if (argc != 3) 9 | err_quit("usage: tcpsend04 "); 10 | 11 | sockfd = Tcp_connect(argv[1], argv[2]); 12 | 13 | Write(sockfd, "123", 3); 14 | printf("wrote 3 bytes of normal data\n"); 15 | 16 | Send(sockfd, "4", 1, MSG_OOB); 17 | printf("wrote 1 byte of OOB data\n"); 18 | 19 | Write(sockfd, "5", 1); 20 | printf("wrote 1 byte of normal data\n"); 21 | 22 | exit(0); 23 | } 24 | -------------------------------------------------------------------------------- /oob/tcpsend05.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd, size; 7 | char buff[16384]; 8 | 9 | if (argc != 3) 10 | err_quit("usage: tcpsend05 "); 11 | 12 | sockfd = Tcp_connect(argv[1], argv[2]); 13 | 14 | size = 32768; 15 | Setsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, &size, sizeof(size)); 16 | 17 | Write(sockfd, buff, 16384); 18 | printf("wrote 16384 bytes of normal data\n"); 19 | sleep(5); 20 | 21 | Send(sockfd, "a", 1, MSG_OOB); 22 | printf("wrote 1 byte of OOB data\n"); 23 | 24 | Write(sockfd, buff, 1024); 25 | printf("wrote 1024 bytes of normal data\n"); 26 | 27 | exit(0); 28 | } 29 | -------------------------------------------------------------------------------- /oob/tcpsend06.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | 8 | if (argc != 3) 9 | err_quit("usage: tcpsend06 "); 10 | 11 | sockfd = Tcp_connect(argv[1], argv[2]); 12 | 13 | Write(sockfd, "123", 3); 14 | printf("wrote 3 bytes of normal data\n"); 15 | 16 | Send(sockfd, "4", 1, MSG_OOB); 17 | printf("wrote 1 byte of OOB data\n"); 18 | 19 | Write(sockfd, "5", 1); 20 | printf("wrote 1 byte of normal data\n"); 21 | 22 | Send(sockfd, "6", 1, MSG_OOB); 23 | printf("wrote 1 byte of OOB data\n"); 24 | 25 | Write(sockfd, "7", 1); 26 | printf("wrote 1 byte of normal data\n"); 27 | 28 | exit(0); 29 | } 30 | -------------------------------------------------------------------------------- /ping/Makefile: -------------------------------------------------------------------------------- 1 | include ../Make.defines 2 | 3 | OBJS = init_v6.o main.o proc_v4.o proc_v6.o readloop.o \ 4 | send_v4.o send_v6.o sig_alrm.o tv_sub.o 5 | PROGS = ping 6 | 7 | all: ${PROGS} 8 | 9 | ping: ${OBJS} 10 | ${CC} ${CFLAGS} -o $@ ${OBJS} ${LIBS} 11 | 12 | clean: 13 | rm -f ${PROGS} ${CLEANFILES} 14 | -------------------------------------------------------------------------------- /ping/init_v6.c: -------------------------------------------------------------------------------- 1 | #include "ping.h" 2 | 3 | void 4 | init_v6() 5 | { 6 | #ifdef IPV6 7 | int on = 1; 8 | 9 | if (verbose == 0) { 10 | /* install a filter that only passes ICMP6_ECHO_REPLY unless verbose */ 11 | struct icmp6_filter myfilt; 12 | ICMP6_FILTER_SETBLOCKALL(&myfilt); 13 | ICMP6_FILTER_SETPASS(ICMP6_ECHO_REPLY, &myfilt); 14 | setsockopt(sockfd, IPPROTO_IPV6, ICMP6_FILTER, &myfilt, sizeof(myfilt)); 15 | /* ignore error return; the filter is an optimization */ 16 | } 17 | 18 | /* ignore error returned below; we just won't receive the hop limit */ 19 | #ifdef IPV6_RECVHOPLIMIT 20 | /* RFC 3542 */ 21 | setsockopt(sockfd, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &on, sizeof(on)); 22 | #else 23 | /* RFC 2292 */ 24 | setsockopt(sockfd, IPPROTO_IPV6, IPV6_HOPLIMIT, &on, sizeof(on)); 25 | #endif 26 | #endif 27 | } 28 | -------------------------------------------------------------------------------- /ping/old/ip6.h: -------------------------------------------------------------------------------- 1 | struct ip6hdr { 2 | union { 3 | struct ip6hdrctl { 4 | u_int32_t ctl6_flow; /* 24 bits of flow-ID */ 5 | u_int16_t ctl6_plen; /* payload length */ 6 | u_int8_t ctl6_nxt; /* next header */ 7 | u_int8_t ctl6_hlim; /* hop limit */ 8 | } un_ctl6; 9 | u_int8_t un_vfc; /* 4 bits version, 4 bits reserved */ 10 | } ip6_ctlun; 11 | struct in6_addr ip6_src; /* source address */ 12 | struct in6_addr ip6_dst; /* destination address */ 13 | }; 14 | 15 | #define ip6_vfc ip6_ctlun.un_vfc 16 | #define ip6_flow ip6_ctlun.un_ctl6.ctl6_flow 17 | #define ip6_plen ip6_ctlun.un_ctl6.ctl6_plen 18 | #define ip6_nxt ip6_ctlun.un_ctl6.ctl6_nxt 19 | #define ip6_hlim ip6_ctlun.un_ctl6.ctl6_hlim 20 | #define ip6_hops ip6_ctlun.un_ctl6.ctl6_hlim 21 | -------------------------------------------------------------------------------- /ping/ping_v4.c: -------------------------------------------------------------------------------- 1 | #include "ping.h" 2 | 3 | void 4 | ping_v4(struct hostent *hptr) 5 | { 6 | int size; 7 | char recvbuf[BUFSIZE]; 8 | socklen_t len; 9 | ssize_t n; 10 | struct timeval tval; 11 | 12 | setuid(getuid()); /* don't need special permissions any more */ 13 | 14 | size = 60 * 1024; /* OK if setsockopt fails */ 15 | setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, &size, sizeof(size)); 16 | 17 | 18 | sig_alrm(SIGALRM); /* send first packet */ 19 | 20 | for ( ; ; ) { 21 | len = salen; 22 | n = recvfrom(sockfd, recvbuf, sizeof(recvbuf), 0, sarecv, &len); 23 | if (n < 0) { 24 | if (errno == EINTR) 25 | continue; 26 | else 27 | err_sys("recvfrom error"); 28 | } 29 | 30 | Gettimeofday(&tval, NULL); 31 | (*fptrs.proc_f)(recvbuf, n, &tval); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /ping/send_v4.c: -------------------------------------------------------------------------------- 1 | #include "ping.h" 2 | 3 | void 4 | send_v4(void) 5 | { 6 | int len; 7 | struct icmp *icmp; 8 | 9 | icmp = (struct icmp *) sendbuf; 10 | icmp->icmp_type = ICMP_ECHO; 11 | icmp->icmp_code = 0; 12 | icmp->icmp_id = pid; 13 | icmp->icmp_seq = nsent++; 14 | memset(icmp->icmp_data, 0xa5, datalen); /* fill with pattern */ 15 | Gettimeofday((struct timeval *) icmp->icmp_data, NULL); 16 | 17 | len = 8 + datalen; /* checksum ICMP header and data */ 18 | icmp->icmp_cksum = 0; 19 | icmp->icmp_cksum = in_cksum((u_short *) icmp, len); 20 | 21 | Sendto(sockfd, sendbuf, len, 0, pr->sasend, pr->salen); 22 | } 23 | -------------------------------------------------------------------------------- /ping/send_v6.c: -------------------------------------------------------------------------------- 1 | #include "ping.h" 2 | 3 | void 4 | send_v6() 5 | { 6 | #ifdef IPV6 7 | int len; 8 | struct icmp6_hdr *icmp6; 9 | 10 | icmp6 = (struct icmp6_hdr *) sendbuf; 11 | icmp6->icmp6_type = ICMP6_ECHO_REQUEST; 12 | icmp6->icmp6_code = 0; 13 | icmp6->icmp6_id = pid; 14 | icmp6->icmp6_seq = nsent++; 15 | memset((icmp6 + 1), 0xa5, datalen); /* fill with pattern */ 16 | Gettimeofday((struct timeval *) (icmp6 + 1), NULL); 17 | 18 | len = 8 + datalen; /* 8-byte ICMPv6 header */ 19 | 20 | Sendto(sockfd, sendbuf, len, 0, pr->sasend, pr->salen); 21 | /* 4kernel calculates and stores checksum for us */ 22 | #endif /* IPV6 */ 23 | } 24 | -------------------------------------------------------------------------------- /ping/sig_alrm.c: -------------------------------------------------------------------------------- 1 | #include "ping.h" 2 | 3 | void 4 | sig_alrm(int signo) 5 | { 6 | (*pr->fsend)(); 7 | 8 | alarm(1); 9 | return; 10 | } 11 | -------------------------------------------------------------------------------- /ping/tv_sub.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | tv_sub(struct timeval *out, struct timeval *in) 5 | { 6 | if ( (out->tv_usec -= in->tv_usec) < 0) { /* out -= in */ 7 | --out->tv_sec; 8 | out->tv_usec += 1000000; 9 | } 10 | out->tv_sec -= in->tv_sec; 11 | } 12 | -------------------------------------------------------------------------------- /route/Makefile: -------------------------------------------------------------------------------- 1 | include ../Make.defines 2 | 3 | PROGS = checkudpsum getrt mynetstat \ 4 | prifinfo prifindex prifname prifnameindex 5 | 6 | all: ${PROGS} 7 | 8 | checkudpsum: checkudpsum.o 9 | ${CC} ${CFLAGS} -o $@ checkudpsum.o ${LIBS} 10 | 11 | getrt: getrt.o 12 | ${CC} ${CFLAGS} -o $@ getrt.o ${LIBS} 13 | 14 | prifinfo: prifinfo.o get_ifi_info.o 15 | ${CC} ${CFLAGS} -o $@ prifinfo.o get_ifi_info.o ${LIBS} 16 | 17 | prifindex: prifindex.o 18 | ${CC} ${CFLAGS} -o $@ prifindex.o ${LIBS} 19 | 20 | prifname: prifname.o 21 | ${CC} ${CFLAGS} -o $@ prifname.o ${LIBS} 22 | 23 | prifnameindex: prifnameindex.o 24 | ${CC} ${CFLAGS} -o $@ prifnameindex.o ${LIBS} 25 | 26 | mynetstat: mynetstat.o 27 | ${CC} ${CFLAGS} -o $@ mynetstat.o ${LIBS} 28 | 29 | clean: 30 | rm -f ${PROGS} ${CLEANFILES} 31 | -------------------------------------------------------------------------------- /route/checkudpsum.c: -------------------------------------------------------------------------------- 1 | #include "unproute.h" 2 | #include 3 | #include 4 | #include /* for UDPCTL_xxx constants */ 5 | 6 | int 7 | main(int argc, char **argv) 8 | { 9 | int mib[4], val; 10 | size_t len; 11 | 12 | mib[0] = CTL_NET; 13 | mib[1] = AF_INET; 14 | mib[2] = IPPROTO_UDP; 15 | mib[3] = UDPCTL_CHECKSUM; 16 | 17 | len = sizeof(val); 18 | Sysctl(mib, 4, &val, &len, NULL, 0); 19 | printf("udp checksum flag: %d\n", val); 20 | 21 | exit(0); 22 | } 23 | -------------------------------------------------------------------------------- /route/prifindex.c: -------------------------------------------------------------------------------- 1 | #include "unpifi.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | if (argc != 2) 7 | err_quit("usage: prifname "); 8 | 9 | printf("interface index = %d\n", If_nametoindex(argv[1])); 10 | exit(0); 11 | } 12 | -------------------------------------------------------------------------------- /route/prifname.c: -------------------------------------------------------------------------------- 1 | #include "unpifi.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | char name[16]; 7 | 8 | if (argc != 2) 9 | err_quit("usage: prifname "); 10 | 11 | printf("interface name = %s\n", If_indextoname(atoi(argv[1]), name)); 12 | exit(0); 13 | } 14 | -------------------------------------------------------------------------------- /route/unproute.h: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | #include /* if_msghdr{} */ 3 | #include /* sockaddr_sdl{} */ 4 | #include /* RTA_xxx constants */ 5 | #include 6 | 7 | #ifdef HAVE_SYS_SYSCTL_H 8 | #include /* sysctl() */ 9 | #endif 10 | 11 | /* function prototypes */ 12 | void get_rtaddrs(int, struct sockaddr *, struct sockaddr **); 13 | char *net_rt_iflist(int, int, size_t *); 14 | char *net_rt_dump(int, int, size_t *); 15 | char *sock_masktop(struct sockaddr *, socklen_t); 16 | 17 | /* wrapper functions */ 18 | char *Net_rt_iflist(int, int, size_t *); 19 | char *Net_rt_dump(int, int, size_t *); 20 | #define Sock_masktop(a,b) sock_masktop((a), (b)) 21 | -------------------------------------------------------------------------------- /rtt/Makefile: -------------------------------------------------------------------------------- 1 | include ../Make.defines 2 | 3 | PROGS = udpcli01 4 | 5 | all: ${PROGS} 6 | 7 | udpcli01: udpcli01.o dg_cli.o dg_send_recv.o 8 | ${CC} ${CFLAGS} -o $@ udpcli01.o dg_cli.o dg_send_recv.o ${LIBS} 9 | 10 | clean: 11 | rm -f ${PROGS} ${CLEANFILES} 12 | -------------------------------------------------------------------------------- /rtt/dg_cli.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | ssize_t Dg_send_recv(int, const void *, size_t, void *, size_t, 4 | const SA *, socklen_t); 5 | 6 | void 7 | dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t servlen) 8 | { 9 | ssize_t n; 10 | char sendline[MAXLINE], recvline[MAXLINE + 1]; 11 | 12 | while (Fgets(sendline, MAXLINE, fp) != NULL) { 13 | 14 | n = Dg_send_recv(sockfd, sendline, strlen(sendline), 15 | recvline, MAXLINE, pservaddr, servlen); 16 | 17 | recvline[n] = 0; /* null terminate */ 18 | Fputs(recvline, stdout); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /rtt/dg_echo.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | dg_echo(int sockfd, SA *pcliaddr, socklen_t clilen) 5 | { 6 | int n; 7 | socklen_t len; 8 | char mesg[MAXLINE]; 9 | 10 | for ( ; ; ) { 11 | len = clilen; 12 | n = Recvfrom(sockfd, mesg, MAXLINE, 0, pcliaddr, &len); 13 | 14 | Sendto(sockfd, mesg, n, 0, pcliaddr, clilen); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /rtt/udpcli01.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: udpcli "); 11 | 12 | bzero(&servaddr, sizeof(servaddr)); 13 | servaddr.sin_family = AF_INET; 14 | servaddr.sin_port = htons(7); 15 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 16 | 17 | sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 18 | 19 | dg_cli(stdin, sockfd, (SA *) &servaddr, sizeof(servaddr)); 20 | 21 | exit(0); 22 | } 23 | -------------------------------------------------------------------------------- /sctp/sctp_addr_to_associd.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | sctp_assoc_t 4 | sctp_address_to_associd(int sock_fd, struct sockaddr *sa, socklen_t salen) 5 | { 6 | struct sctp_paddrparams sp; 7 | int siz; 8 | 9 | siz = sizeof(struct sctp_paddrparams); 10 | bzero(&sp,siz); 11 | memcpy(&sp.spp_address,sa,salen); 12 | sctp_opt_info(sock_fd,0, 13 | SCTP_PEER_ADDR_PARAMS, &sp, &siz); 14 | return(sp.spp_assoc_id); 15 | } 16 | -------------------------------------------------------------------------------- /sctp/sctp_bindargs.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | sctp_bind_arg_list(int sock_fd, char **argv, int argc) 5 | { 6 | struct addrinfo *addr; 7 | char *bindbuf, *p, portbuf[10]; 8 | int addrcnt=0; 9 | int i; 10 | 11 | bindbuf = (char *)Calloc(argc, sizeof(struct sockaddr_storage)); 12 | p = bindbuf; 13 | sprintf(portbuf, "%d", SERV_PORT); 14 | for( i=0; iai_addr, addr->ai_addrlen); 17 | freeaddrinfo(addr); 18 | addrcnt++; 19 | p += addr->ai_addrlen; 20 | } 21 | Sctp_bindx(sock_fd,(SA *)bindbuf,addrcnt,SCTP_BINDX_ADD_ADDR); 22 | free(bindbuf); 23 | return(0); 24 | } 25 | -------------------------------------------------------------------------------- /sctp/sctp_check_notify.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | check_notification(int sock_fd,char *recvline,int rd_len) 5 | { 6 | union sctp_notification *snp; 7 | struct sctp_assoc_change *sac; 8 | struct sockaddr_storage *sal,*sar; 9 | int num_rem, num_loc; 10 | 11 | snp = (union sctp_notification *)recvline; 12 | if(snp->sn_header.sn_type == SCTP_ASSOC_CHANGE) { 13 | sac = &snp->sn_assoc_change; 14 | if((sac->sac_state == SCTP_COMM_UP) || 15 | (sac->sac_state == SCTP_RESTART)) { 16 | num_rem = sctp_getpaddrs(sock_fd,sac->sac_assoc_id,&sar); 17 | printf("There are %d remote addresses and they are:\n", 18 | num_rem); 19 | sctp_print_addresses(sar,num_rem); 20 | sctp_freepaddrs(sar); 21 | 22 | num_loc = sctp_getladdrs(sock_fd,sac->sac_assoc_id,&sal); 23 | printf("There are %d local addresses and they are:\n", 24 | num_loc); 25 | sctp_print_addresses(sal,num_loc); 26 | sctp_freeladdrs(sal); 27 | } 28 | } 29 | 30 | } 31 | -------------------------------------------------------------------------------- /sctp/sctp_getnostrm.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | sctp_get_no_strms(int sock_fd,struct sockaddr *to, socklen_t tolen) 5 | { 6 | int retsz; 7 | struct sctp_status status; 8 | retsz = sizeof(status); 9 | bzero(&status,sizeof(status)); 10 | 11 | status.sstat_assoc_id = sctp_address_to_associd(sock_fd,to,tolen); 12 | Getsockopt(sock_fd,IPPROTO_SCTP, SCTP_STATUS, 13 | &status, &retsz); 14 | return(status.sstat_outstrms); 15 | } 16 | -------------------------------------------------------------------------------- /sctp/sctp_modify_hb.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int heartbeat_action(int sock_fd, struct sockaddr *sa, socklen_t salen, 4 | u_int value) 5 | { 6 | struct sctp_paddrparams sp; 7 | int siz; 8 | 9 | bzero(&sp,sizeof(sp)); 10 | sp.spp_hbinterval = value; 11 | memcpy((caddr_t)&sp.spp_address,sa,salen); 12 | Setsockopt(sock_fd,IPPROTO_SCTP, 13 | SCTP_PEER_ADDR_PARAMS, &sp, sizeof(sp)); 14 | return(0); 15 | } 16 | -------------------------------------------------------------------------------- /sctp/sctp_print_addrs.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | sctp_print_addresses(struct sockaddr_storage *addrs, int num) 5 | { 6 | struct sockaddr_storage *ss; 7 | int i,salen; 8 | 9 | ss = addrs; 10 | for(i=0; iss_len; 14 | #else 15 | switch(ss->ss_family) { 16 | case AF_INET: 17 | salen = sizeof(struct sockaddr_in); 18 | break; 19 | #ifdef IPV6 20 | case AF_INET6: 21 | salen = sizeof(struct sockaddr_in6); 22 | break; 23 | #endif 24 | default: 25 | err_quit("sctp_print_addresses: unknown AF"); 26 | break; 27 | } 28 | #endif 29 | ss = (struct sockaddr_storage *)((char *)ss + salen); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /sctp/sctpclient04.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sock_fd; 7 | struct sockaddr_in servaddr; 8 | struct sctp_event_subscribe evnts; 9 | 10 | if(argc != 2) 11 | err_quit("Missing host argument - use '%s host'\n", 12 | argv[0]); 13 | sock_fd = Socket(AF_INET, SOCK_SEQPACKET, IPPROTO_SCTP); 14 | bzero(&servaddr, sizeof(servaddr)); 15 | servaddr.sin_family = AF_INET; 16 | servaddr.sin_addr.s_addr = htonl(INADDR_ANY); 17 | servaddr.sin_port = htons(SERV_PORT); 18 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 19 | /* include mod_client04 */ 20 | bzero(&evnts, sizeof(evnts)); 21 | evnts.sctp_data_io_event = 1; 22 | evnts.sctp_association_event = 1; 23 | Setsockopt(sock_fd,IPPROTO_SCTP, SCTP_EVENTS, 24 | &evnts, sizeof(evnts)); 25 | 26 | sctpstr_cli(stdin,sock_fd,(SA *)&servaddr,sizeof(servaddr)); 27 | /* end mod_client04 */ 28 | close(sock_fd); 29 | return(0); 30 | } 31 | -------------------------------------------------------------------------------- /select/Makefile: -------------------------------------------------------------------------------- 1 | include ../Make.defines 2 | 3 | PROGS = tcpcli01 tcpcli02 tcpcli03 4 | 5 | all: ${PROGS} 6 | 7 | tcpcli01: tcpcli01.o strcliselect01.o 8 | ${CC} ${CFLAGS} -o $@ tcpcli01.o strcliselect01.o ${LIBS} 9 | 10 | tcpcli02: tcpcli02.o strcliselect02.o 11 | ${CC} ${CFLAGS} -o $@ tcpcli02.o strcliselect02.o ${LIBS} 12 | 13 | tcpcli03: tcpcli03.o 14 | ${CC} ${CFLAGS} -o $@ tcpcli03.o ${LIBS} 15 | 16 | clean: 17 | rm -f ${PROGS} ${CLEANFILES} 18 | -------------------------------------------------------------------------------- /select/strcliselect01.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | str_cli(FILE *fp, int sockfd) 5 | { 6 | int maxfdp1; 7 | fd_set rset; 8 | char sendline[MAXLINE], recvline[MAXLINE]; 9 | 10 | FD_ZERO(&rset); 11 | for ( ; ; ) { 12 | FD_SET(fileno(fp), &rset); 13 | FD_SET(sockfd, &rset); 14 | maxfdp1 = max(fileno(fp), sockfd) + 1; 15 | Select(maxfdp1, &rset, NULL, NULL, NULL); 16 | 17 | if (FD_ISSET(sockfd, &rset)) { /* socket is readable */ 18 | if (Readline(sockfd, recvline, MAXLINE) == 0) 19 | err_quit("str_cli: server terminated prematurely"); 20 | Fputs(recvline, stdout); 21 | } 22 | 23 | if (FD_ISSET(fileno(fp), &rset)) { /* input is readable */ 24 | if (Fgets(sendline, MAXLINE, fp) == NULL) 25 | return; /* all done */ 26 | Writen(sockfd, sendline, strlen(sendline)); 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /select/tcpcli01.c: -------------------------------------------------------------------------------- 1 | /* Use standard echo server; baseline measurements for nonblocking version */ 2 | #include "unp.h" 3 | 4 | int 5 | main(int argc, char **argv) 6 | { 7 | int sockfd; 8 | struct sockaddr_in servaddr; 9 | 10 | if (argc != 2) 11 | err_quit("usage: tcpcli "); 12 | 13 | sockfd = Socket(AF_INET, SOCK_STREAM, 0); 14 | 15 | bzero(&servaddr, sizeof(servaddr)); 16 | servaddr.sin_family = AF_INET; 17 | servaddr.sin_port = htons(7); 18 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 19 | 20 | Connect(sockfd, (SA *) &servaddr, sizeof(servaddr)); 21 | 22 | str_cli(stdin, sockfd); /* do it all */ 23 | 24 | exit(0); 25 | } 26 | -------------------------------------------------------------------------------- /select/tcpcli02.c: -------------------------------------------------------------------------------- 1 | /* Use standard echo server; baseline measurements for nonblocking version */ 2 | #include "unp.h" 3 | 4 | int 5 | main(int argc, char **argv) 6 | { 7 | int sockfd; 8 | struct sockaddr_in servaddr; 9 | 10 | if (argc != 2) 11 | err_quit("usage: tcpcli "); 12 | 13 | sockfd = Socket(AF_INET, SOCK_STREAM, 0); 14 | 15 | bzero(&servaddr, sizeof(servaddr)); 16 | servaddr.sin_family = AF_INET; 17 | servaddr.sin_port = htons(7); 18 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 19 | 20 | Connect(sockfd, (SA *) &servaddr, sizeof(servaddr)); 21 | 22 | str_cli(stdin, sockfd); /* do it all */ 23 | 24 | exit(0); 25 | } 26 | -------------------------------------------------------------------------------- /select/tcpcli03.c: -------------------------------------------------------------------------------- 1 | /* Test shutdown(fd,SHUT_RD) and see what happens */ 2 | #include "unp.h" 3 | 4 | int 5 | main(int argc, char **argv) 6 | { 7 | int sockfd; 8 | struct sockaddr_in servaddr; 9 | 10 | if (argc != 2) 11 | err_quit("usage: tcpcli03 "); 12 | 13 | sockfd = Socket(AF_INET, SOCK_STREAM, 0); 14 | 15 | bzero(&servaddr, sizeof(servaddr)); 16 | servaddr.sin_family = AF_INET; 17 | servaddr.sin_port = htons(19); /* chargen server */ 18 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 19 | 20 | Connect(sockfd, (SA *) &servaddr, sizeof(servaddr)); 21 | 22 | shutdown(sockfd, SHUT_RD); 23 | 24 | pause(); 25 | 26 | exit(0); 27 | } 28 | -------------------------------------------------------------------------------- /server/child.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | pid_t child_pid; /* process ID */ 3 | int child_pipefd; /* parent's stream pipe to/from child */ 4 | int child_status; /* 0 = ready */ 5 | long child_count; /* # connections handled */ 6 | } Child; 7 | 8 | Child *cptr; /* array of Child structures; calloc'ed */ 9 | -------------------------------------------------------------------------------- /server/child.lh: -------------------------------------------------------------------------------- 1 | typedef struct {## 1 ##src/server/child.h## 2 | pid_t child_pid; /* process ID */## 2 ##src/server/child.h## 3 | int child_pipefd; /* parent's stream pipe to/from child */## 3 ##src/server/child.h## 4 | int child_status; /* 0 = ready */## 4 ##src/server/child.h## 5 | long child_count; /* #connections handled */## 5 ##src/server/child.h## 6 | } Child;## 6 ##src/server/child.h## 7 | 8 | Child *cptr; /* array of Child structures; calloc'ed */## 7 ##src/server/child.h## 9 | -------------------------------------------------------------------------------- /server/child02.c: -------------------------------------------------------------------------------- 1 | /* include child_make */ 2 | #include "unp.h" 3 | 4 | pid_t 5 | child_make(int i, int listenfd, int addrlen) 6 | { 7 | pid_t pid; 8 | void child_main(int, int, int); 9 | 10 | if ( (pid = Fork()) > 0) 11 | return(pid); /* parent */ 12 | 13 | child_main(i, listenfd, addrlen); /* never returns */ 14 | } 15 | /* end child_make */ 16 | 17 | /* include child_main */ 18 | void 19 | child_main(int i, int listenfd, int addrlen) 20 | { 21 | int connfd; 22 | void web_child(int); 23 | socklen_t clilen; 24 | struct sockaddr *cliaddr; 25 | 26 | cliaddr = Malloc(addrlen); 27 | 28 | printf("child %ld starting\n", (long) getpid()); 29 | for ( ; ; ) { 30 | clilen = addrlen; 31 | connfd = Accept(listenfd, cliaddr, &clilen); 32 | 33 | web_child(connfd); /* process the request */ 34 | Close(connfd); 35 | } 36 | } 37 | /* end child_main */ 38 | -------------------------------------------------------------------------------- /server/child02l.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | pid_t 4 | child_make(int i, int listenfd, int addrlen) 5 | { 6 | pid_t pid; 7 | void child_main(int, int, int); 8 | 9 | if ( (pid = Fork()) > 0) 10 | return(pid); /* parent */ 11 | 12 | child_main(i, listenfd, addrlen); /* never returns */ 13 | } 14 | 15 | void 16 | child_main(int i, int listenfd, int addrlen) 17 | { 18 | int connfd; 19 | void web_child(int); 20 | fd_set rset; 21 | socklen_t clilen; 22 | struct sockaddr *cliaddr; 23 | 24 | cliaddr = Malloc(addrlen); 25 | 26 | printf("child %ld starting\n", (long) getpid()); 27 | FD_ZERO(&rset); 28 | for ( ; ; ) { 29 | FD_SET(listenfd, &rset); 30 | Select(listenfd+1, &rset, NULL, NULL, NULL); 31 | if (FD_ISSET(listenfd, &rset) == 0) 32 | err_quit("listenfd readable"); 33 | 34 | clilen = addrlen; 35 | connfd = Accept(listenfd, cliaddr, &clilen); 36 | 37 | web_child(connfd); /* process the request */ 38 | Close(connfd); 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /server/child02m.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | pid_t 4 | child_make(int i, int listenfd, int addrlen) 5 | { 6 | pid_t pid; 7 | void child_main(int, int, int); 8 | 9 | if ( (pid = Fork()) > 0) 10 | return(pid); /* parent */ 11 | 12 | child_main(i, listenfd, addrlen); /* never returns */ 13 | } 14 | 15 | void 16 | child_main(int i, int listenfd, int addrlen) 17 | { 18 | int connfd; 19 | void web_child(int); 20 | socklen_t clilen; 21 | struct sockaddr *cliaddr; 22 | extern long *cptr; 23 | 24 | cliaddr = Malloc(addrlen); 25 | 26 | printf("child %ld starting\n", (long) getpid()); 27 | for ( ; ; ) { 28 | clilen = addrlen; 29 | connfd = Accept(listenfd, cliaddr, &clilen); 30 | cptr[i]++; 31 | 32 | web_child(connfd); /* process the request */ 33 | Close(connfd); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /server/child03.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | pid_t 4 | child_make(int i, int listenfd, int addrlen) 5 | { 6 | pid_t pid; 7 | void child_main(int, int, int); 8 | 9 | if ( (pid = Fork()) > 0) 10 | return(pid); /* parent */ 11 | 12 | child_main(i, listenfd, addrlen); /* never returns */ 13 | } 14 | 15 | void 16 | child_main(int i, int listenfd, int addrlen) 17 | { 18 | int connfd; 19 | void web_child(int); 20 | socklen_t clilen; 21 | struct sockaddr *cliaddr; 22 | 23 | cliaddr = Malloc(addrlen); 24 | 25 | printf("child %ld starting\n", (long) getpid()); 26 | for ( ; ; ) { 27 | clilen = addrlen; 28 | my_lock_wait(); 29 | connfd = Accept(listenfd, cliaddr, &clilen); 30 | my_lock_release(); 31 | 32 | web_child(connfd); /* process the request */ 33 | Close(connfd); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /server/child03m.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | pid_t 4 | child_make(int i, int listenfd, int addrlen) 5 | { 6 | pid_t pid; 7 | void child_main(int, int, int); 8 | 9 | if ( (pid = Fork()) > 0) 10 | return(pid); /* parent */ 11 | 12 | child_main(i, listenfd, addrlen); /* never returns */ 13 | } 14 | 15 | void 16 | child_main(int i, int listenfd, int addrlen) 17 | { 18 | int connfd; 19 | void web_child(int); 20 | socklen_t clilen; 21 | struct sockaddr *cliaddr; 22 | extern long *cptr; 23 | 24 | cliaddr = Malloc(addrlen); 25 | 26 | printf("child %ld starting\n", (long) getpid()); 27 | for ( ; ; ) { 28 | clilen = addrlen; 29 | my_lock_wait(); 30 | connfd = Accept(listenfd, cliaddr, &clilen); 31 | my_lock_release(); 32 | cptr[i]++; 33 | 34 | web_child(connfd); /* process the request */ 35 | Close(connfd); 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /server/child04.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | pid_t 4 | child_make(int i, int listenfd, int addrlen) 5 | { 6 | pid_t pid; 7 | void child_main(int, int, int); 8 | 9 | if ( (pid = Fork()) > 0) 10 | return(pid); /* parent */ 11 | 12 | child_main(i, listenfd, addrlen); /* never returns */ 13 | } 14 | 15 | void 16 | child_main(int i, int listenfd, int addrlen) 17 | { 18 | int connfd; 19 | void web_child(int); 20 | socklen_t clilen; 21 | struct sockaddr *cliaddr; 22 | 23 | cliaddr = Malloc(addrlen); 24 | 25 | printf("child %ld starting\n", (long) getpid()); 26 | for ( ; ; ) { 27 | clilen = addrlen; 28 | my_lock_wait(); 29 | connfd = Accept(listenfd, cliaddr, &clilen); 30 | my_lock_release(); 31 | 32 | web_child(connfd); /* process the request */ 33 | Close(connfd); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /server/lock_pthread.c: -------------------------------------------------------------------------------- 1 | /* include my_lock_init */ 2 | #include "unpthread.h" 3 | #include 4 | 5 | static pthread_mutex_t *mptr; /* actual mutex will be in shared memory */ 6 | 7 | void 8 | my_lock_init(char *pathname) 9 | { 10 | int fd; 11 | pthread_mutexattr_t mattr; 12 | 13 | fd = Open("/dev/zero", O_RDWR, 0); 14 | 15 | mptr = Mmap(0, sizeof(pthread_mutex_t), PROT_READ | PROT_WRITE, 16 | MAP_SHARED, fd, 0); 17 | Close(fd); 18 | 19 | Pthread_mutexattr_init(&mattr); 20 | Pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED); 21 | Pthread_mutex_init(mptr, &mattr); 22 | } 23 | /* end my_lock_init */ 24 | 25 | /* include my_lock_wait */ 26 | void 27 | my_lock_wait() 28 | { 29 | Pthread_mutex_lock(mptr); 30 | } 31 | 32 | void 33 | my_lock_release() 34 | { 35 | Pthread_mutex_unlock(mptr); 36 | } 37 | /* end my_lock_wait */ 38 | -------------------------------------------------------------------------------- /server/meter.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | #include 3 | 4 | /* 5 | * Allocate an array of "nchildren" longs in shared memory that can 6 | * be used as a counter by each child of how many clients it services. 7 | * See pp. 467-470 of "Advanced Programming in the Unix Environment." 8 | */ 9 | 10 | long * 11 | meter(int nchildren) 12 | { 13 | int fd; 14 | long *ptr; 15 | 16 | #ifdef MAP_ANON 17 | ptr = Mmap(0, nchildren*sizeof(long), PROT_READ | PROT_WRITE, 18 | MAP_ANON | MAP_SHARED, -1, 0); 19 | #else 20 | fd = Open("/dev/zero", O_RDWR, 0); 21 | 22 | ptr = Mmap(0, nchildren*sizeof(long), PROT_READ | PROT_WRITE, 23 | MAP_SHARED, fd, 0); 24 | Close(fd); 25 | #endif 26 | 27 | return(ptr); 28 | } 29 | -------------------------------------------------------------------------------- /server/pr_cpu_time.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | #include 3 | 4 | #ifndef HAVE_GETRUSAGE_PROTO 5 | int getrusage(int, struct rusage *); 6 | #endif 7 | 8 | void 9 | pr_cpu_time(void) 10 | { 11 | double user, sys; 12 | struct rusage myusage, childusage; 13 | 14 | if (getrusage(RUSAGE_SELF, &myusage) < 0) 15 | err_sys("getrusage error"); 16 | if (getrusage(RUSAGE_CHILDREN, &childusage) < 0) 17 | err_sys("getrusage error"); 18 | 19 | user = (double) myusage.ru_utime.tv_sec + 20 | myusage.ru_utime.tv_usec/1000000.0; 21 | user += (double) childusage.ru_utime.tv_sec + 22 | childusage.ru_utime.tv_usec/1000000.0; 23 | sys = (double) myusage.ru_stime.tv_sec + 24 | myusage.ru_stime.tv_usec/1000000.0; 25 | sys += (double) childusage.ru_stime.tv_sec + 26 | childusage.ru_stime.tv_usec/1000000.0; 27 | 28 | printf("\nuser time = %g, sys time = %g\n", user, sys); 29 | } 30 | -------------------------------------------------------------------------------- /server/pthread07.c: -------------------------------------------------------------------------------- 1 | #include "unpthread.h" 2 | #include "pthread07.h" 3 | 4 | void 5 | thread_make(int i) 6 | { 7 | void *thread_main(void *); 8 | 9 | Pthread_create(&tptr[i].thread_tid, NULL, &thread_main, (void *) i); 10 | return; /* main thread returns */ 11 | } 12 | 13 | void * 14 | thread_main(void *arg) 15 | { 16 | int connfd; 17 | void web_child(int); 18 | socklen_t clilen; 19 | struct sockaddr *cliaddr; 20 | 21 | cliaddr = Malloc(addrlen); 22 | 23 | printf("thread %d starting\n", (int) arg); 24 | for ( ; ; ) { 25 | clilen = addrlen; 26 | Pthread_mutex_lock(&mlock); 27 | connfd = Accept(listenfd, cliaddr, &clilen); 28 | Pthread_mutex_unlock(&mlock); 29 | tptr[(int) arg].thread_count++; 30 | 31 | web_child(connfd); /* process request */ 32 | Close(connfd); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /server/pthread07.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | pthread_t thread_tid; /* thread ID */ 3 | long thread_count; /* # connections handled */ 4 | } Thread; 5 | Thread *tptr; /* array of Thread structures; calloc'ed */ 6 | 7 | int listenfd, nthreads; 8 | socklen_t addrlen; 9 | pthread_mutex_t mlock; 10 | -------------------------------------------------------------------------------- /server/pthread08.c: -------------------------------------------------------------------------------- 1 | #include "unpthread.h" 2 | #include "pthread08.h" 3 | 4 | void 5 | thread_make(int i) 6 | { 7 | void *thread_main(void *); 8 | 9 | Pthread_create(&tptr[i].thread_tid, NULL, &thread_main, (void *) i); 10 | return; /* main thread returns */ 11 | } 12 | 13 | void * 14 | thread_main(void *arg) 15 | { 16 | int connfd; 17 | void web_child(int); 18 | 19 | printf("thread %d starting\n", (int) arg); 20 | for ( ; ; ) { 21 | Pthread_mutex_lock(&clifd_mutex); 22 | while (iget == iput) 23 | Pthread_cond_wait(&clifd_cond, &clifd_mutex); 24 | connfd = clifd[iget]; /* connected socket to service */ 25 | if (++iget == MAXNCLI) 26 | iget = 0; 27 | Pthread_mutex_unlock(&clifd_mutex); 28 | tptr[(int) arg].thread_count++; 29 | 30 | web_child(connfd); /* process request */ 31 | Close(connfd); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /server/pthread08.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | pthread_t thread_tid; /* thread ID */ 3 | long thread_count; /* # connections handled */ 4 | } Thread; 5 | Thread *tptr; /* array of Thread structures; calloc'ed */ 6 | 7 | #define MAXNCLI 32 8 | int clifd[MAXNCLI], iget, iput; 9 | pthread_mutex_t clifd_mutex; 10 | pthread_cond_t clifd_cond; 11 | -------------------------------------------------------------------------------- /server/pthread09.c: -------------------------------------------------------------------------------- 1 | #include "unpthread.h" 2 | #include "pthread09.h" 3 | 4 | void 5 | thread_make(int i) 6 | { 7 | void *thread_main(void *); 8 | 9 | Pthread_create(&tptr[i].thread_tid, NULL, &thread_main, (void *) i); 10 | return; /* main thread returns */ 11 | } 12 | 13 | void * 14 | thread_main(void *arg) 15 | { 16 | int connfd; 17 | void web_child(int); 18 | socklen_t clilen; 19 | struct sockaddr *cliaddr; 20 | 21 | cliaddr = Malloc(addrlen); 22 | 23 | printf("thread %d starting\n", (int) arg); 24 | for ( ; ; ) { 25 | clilen = addrlen; 26 | connfd = Accept(listenfd, cliaddr, &clilen); 27 | tptr[(int) arg].thread_count++; 28 | 29 | web_child(connfd); /* process the request */ 30 | Close(connfd); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /server/pthread09.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | pthread_t thread_tid; /* thread ID */ 3 | long thread_count; /* #connections handled */ 4 | } Thread; 5 | Thread *tptr; /* array of Thread structures; calloc'ed */ 6 | 7 | int listenfd, nthreads; 8 | socklen_t addrlen; 9 | -------------------------------------------------------------------------------- /server/readline.c: -------------------------------------------------------------------------------- 1 | /* include readline */ 2 | #include "unp.h" 3 | 4 | ssize_t 5 | readline(int fd, void *vptr, size_t maxlen) 6 | { 7 | ssize_t n, rc; 8 | char c, *ptr; 9 | 10 | ptr = vptr; 11 | for (n = 1; n < maxlen; n++) { 12 | if ( (rc = read(fd, &c, 1)) == 1) { 13 | *ptr++ = c; 14 | if (c == '\n') 15 | break; 16 | } else if (rc == 0) { 17 | if (n == 1) 18 | return(0); /* EOF, no data read */ 19 | else 20 | break; /* EOF, some data was read */ 21 | } else 22 | return(-1); /* error */ 23 | } 24 | 25 | *ptr = 0; 26 | return(n); 27 | } 28 | /* end readline */ 29 | 30 | ssize_t 31 | Readline(int fd, void *ptr, size_t maxlen) 32 | { 33 | ssize_t n; 34 | 35 | if ( (n = readline(fd, ptr, maxlen)) == -1) 36 | err_sys("readline error"); 37 | return(n); 38 | } 39 | -------------------------------------------------------------------------------- /server/readline_r.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | int read_fd; /* caller's descriptor to read from */ 3 | char *read_ptr; /* caller's buffer to read into */ 4 | size_t read_maxlen; /* max #bytes to read */ 5 | /* next three are used internally by the function */ 6 | int rl_cnt; /* initialize to 0 */ 7 | char *rl_bufptr; /* initialize to rl_buf */ 8 | char rl_buf[MAXLINE]; 9 | } Rline; 10 | 11 | void readline_rinit(int, void *, size_t, Rline *); 12 | ssize_t readline_r(Rline *); 13 | ssize_t Readline_r(Rline *); 14 | -------------------------------------------------------------------------------- /server/serv00.c: -------------------------------------------------------------------------------- 1 | /* include serv00 */ 2 | #include "unp.h" 3 | 4 | int 5 | main(int argc, char **argv) 6 | { 7 | int listenfd, connfd; 8 | void sig_int(int), web_child(int); 9 | socklen_t clilen, addrlen; 10 | struct sockaddr *cliaddr; 11 | 12 | if (argc == 2) 13 | listenfd = Tcp_listen(NULL, argv[1], &addrlen); 14 | else if (argc == 3) 15 | listenfd = Tcp_listen(argv[1], argv[2], &addrlen); 16 | else 17 | err_quit("usage: serv00 [ ] "); 18 | cliaddr = Malloc(addrlen); 19 | 20 | Signal(SIGINT, sig_int); 21 | 22 | for ( ; ; ) { 23 | clilen = addrlen; 24 | connfd = Accept(listenfd, cliaddr, &clilen); 25 | 26 | web_child(connfd); /* process the request */ 27 | 28 | Close(connfd); /* parent closes connected socket */ 29 | } 30 | } 31 | /* end serv00 */ 32 | 33 | /* include sigint */ 34 | void 35 | sig_int(int signo) 36 | { 37 | void pr_cpu_time(void); 38 | 39 | pr_cpu_time(); 40 | exit(0); 41 | } 42 | /* end sigint */ 43 | -------------------------------------------------------------------------------- /server/sig_chld_waitpid.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | sig_chld(int signo) 5 | { 6 | pid_t pid; 7 | int stat; 8 | 9 | while ( (pid = waitpid(-1, &stat, WNOHANG)) > 0) { 10 | /* printf("child %d terminated\n", pid); */ 11 | } 12 | return; 13 | } 14 | -------------------------------------------------------------------------------- /server/web_child.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | #define MAXN 16384 /* max # bytes client can request */ 4 | 5 | void 6 | web_child(int sockfd) 7 | { 8 | int ntowrite; 9 | ssize_t nread; 10 | char line[MAXLINE], result[MAXN]; 11 | 12 | for ( ; ; ) { 13 | if ( (nread = Readline(sockfd, line, MAXLINE)) == 0) 14 | return; /* connection closed by other end */ 15 | 16 | /* 4line from client specifies #bytes to write back */ 17 | ntowrite = atol(line); 18 | if ((ntowrite <= 0) || (ntowrite > MAXN)) 19 | err_quit("client request for %d bytes", ntowrite); 20 | 21 | Writen(sockfd, result, ntowrite); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /server/web_child_r.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | #include "readline_r.h" 3 | 4 | #define MAXN 16384 /* max #bytes that a client can request */ 5 | 6 | void 7 | web_child(int sockfd) 8 | { 9 | int ntowrite; 10 | ssize_t nread; 11 | char line[MAXLINE], result[MAXN]; 12 | Rline rline; 13 | 14 | readline_rinit(sockfd, line, MAXLINE, &rline); 15 | for ( ; ; ) { 16 | if ( (nread = Readline_r(&rline)) == 0) 17 | return; /* connection closed by other end */ 18 | 19 | /* line from client specifies #bytes to write back */ 20 | ntowrite = atol(line); 21 | if ((ntowrite <= 0) || (ntowrite > MAXN)) 22 | err_quit("client request for %d bytes", ntowrite); 23 | 24 | Writen(sockfd, result, ntowrite); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /sigio/Makefile: -------------------------------------------------------------------------------- 1 | include ../Make.defines 2 | 3 | PROGS = udpcli01 udpserv01 4 | 5 | all: ${PROGS} 6 | 7 | udpcli01: udpcli01.o dgcli01.o 8 | ${CC} ${CFLAGS} -o $@ udpcli01.o dgcli01.o ${LIBS} 9 | 10 | udpserv01: udpserv01.o dgecho01.o 11 | ${CC} ${CFLAGS} -o $@ udpserv01.o dgecho01.o ${LIBS} 12 | 13 | clean: 14 | rm -f ${PROGS} ${CLEANFILES} 15 | -------------------------------------------------------------------------------- /sigio/dgcli01.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t servlen) 5 | { 6 | int n; 7 | char sendline[MAXLINE], recvline[MAXLINE + 1]; 8 | 9 | while (Fgets(sendline, MAXLINE, fp) != NULL) { 10 | 11 | Sendto(sockfd, sendline, strlen(sendline), 0, pservaddr, servlen); 12 | 13 | n = Recvfrom(sockfd, recvline, MAXLINE, 0, NULL, NULL); 14 | 15 | recvline[n] = 0; /* null terminate */ 16 | Fputs(recvline, stdout); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /sigio/script.1: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | ./udpcli01 140.252.13.35 < /usr/share/misc/termcap > /home/rstevens/temp.1 & 4 | ./udpcli01 140.252.13.35 < /usr/share/misc/termcap > /home/rstevens/temp.2 & 5 | ./udpcli01 140.252.13.35 < /usr/share/misc/termcap > /home/rstevens/temp.3 & 6 | ./udpcli01 140.252.13.35 < /usr/share/misc/termcap > /home/rstevens/temp.4 & 7 | ./udpcli01 140.252.13.35 < /usr/share/misc/termcap > /home/rstevens/temp.5 & 8 | ./udpcli01 140.252.13.35 < /usr/share/misc/termcap > /home/rstevens/temp.6 & 9 | 10 | wait 11 | -------------------------------------------------------------------------------- /sigio/script.2: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | ./udpcli01 140.252.13.37 < /usr/share/lib/termcap > /home/rstevens/temp.1 & 4 | ./udpcli01 140.252.13.37 < /usr/share/lib/termcap > /home/rstevens/temp.2 & 5 | ./udpcli01 140.252.13.37 < /usr/share/lib/termcap > /home/rstevens/temp.3 & 6 | ./udpcli01 140.252.13.37 < /usr/share/lib/termcap > /home/rstevens/temp.4 & 7 | ./udpcli01 140.252.13.37 < /usr/share/lib/termcap > /home/rstevens/temp.5 & 8 | ./udpcli01 140.252.13.37 < /usr/share/lib/termcap > /home/rstevens/temp.6 & 9 | 10 | wait 11 | -------------------------------------------------------------------------------- /sigio/udpcli01.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: udpcli01 "); 11 | 12 | bzero(&servaddr, sizeof(servaddr)); 13 | servaddr.sin_family = AF_INET; 14 | servaddr.sin_port = htons(SERV_PORT); 15 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 16 | 17 | sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 18 | 19 | dg_cli(stdin, sockfd, (SA *) &servaddr, sizeof(servaddr)); 20 | 21 | exit(0); 22 | } 23 | -------------------------------------------------------------------------------- /sigio/udpserv01.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr, cliaddr; 8 | 9 | sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 10 | 11 | bzero(&servaddr, sizeof(servaddr)); 12 | servaddr.sin_family = AF_INET; 13 | servaddr.sin_addr.s_addr = htonl(INADDR_ANY); 14 | servaddr.sin_port = htons(SERV_PORT); 15 | 16 | Bind(sockfd, (SA *) &servaddr, sizeof(servaddr)); 17 | 18 | dg_echo(sockfd, (SA *) &cliaddr, sizeof(cliaddr)); 19 | } 20 | -------------------------------------------------------------------------------- /sock/Makefile: -------------------------------------------------------------------------------- 1 | include ../Make.defines 2 | 3 | PROGS = sock 4 | OBJS = buffers.o cliopen.o crlf.o error.o looptcp.o loopudp.o \ 5 | main.o multicast.o pattern.o servopen.o sleepus.o sockopts.o \ 6 | sourceroute.o sourcetcp.o sourceudp.o sinktcp.o sinkudp.o \ 7 | tellwait.o write.o 8 | 9 | all: ${PROGS} 10 | 11 | ${OBJS}: sock.h 12 | 13 | sock: ${OBJS} 14 | ${CC} ${CFLAGS} -o $@ ${OBJS} ${LIBS} 15 | 16 | clean: 17 | rm -f ${PROGS} core core.* *.o temp.* *.out typescript* 18 | -------------------------------------------------------------------------------- /sock/README: -------------------------------------------------------------------------------- 1 | The source files in this directory are all copyrighted (c) 1993 by 2 | W. Richard Stevens. 3 | 4 | This source files in this directory assume tab stops every 4 positions, 5 | not every 8 (the default). Just ":set tabstop=4" in vi, for example. 6 | 7 | If your system doesn't define the POSIX.1 ssize_t data type, then 8 | delete the appropriate #ifdef/#endif lines at the beginning of "ourhdr.h". 9 | 10 | If your system's doesn't define the variables for getopt(), 11 | then delete the appropriate #ifdef/#endif lines at the beginning of "ourhdr.h". 12 | 13 | If your system doesn't support send() and recv() (e.g., OSF/1) then 14 | delete the appropriate #ifdef/#endif lines at the beginning of "ourhdr.h". 15 | -------------------------------------------------------------------------------- /sock/TODO: -------------------------------------------------------------------------------- 1 | - With -v print IP address after gethostbyname returns. 2 | 3 | - First, option to write() in small chunks. Then option to use writev() 4 | instead of write(). See what happens, with and without TCO_NODELAY. 5 | -------------------------------------------------------------------------------- /sock/pattern.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 1993 W. Richard Stevens. All rights reserved. 3 | * Permission to use or modify this software and its documentation only for 4 | * educational purposes and without fee is hereby granted, provided that 5 | * the above copyright notice appear in all copies. The author makes no 6 | * representations about the suitability of this software for any purpose. 7 | * It is provided "as is" without express or implied warranty. 8 | */ 9 | 10 | #include "sock.h" 11 | #include 12 | 13 | void 14 | pattern(char *ptr, int len) 15 | { 16 | char c; 17 | 18 | c = 0; 19 | while(len-- > 0) { 20 | while(isprint((c & 0x7F)) == 0) 21 | c++; /* skip over nonprinting characters */ 22 | *ptr++ = (c++ & 0x7F); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /sock/sleepus.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include "ourhdr.h" 6 | 7 | void 8 | sleep_us(unsigned int nusecs) 9 | { 10 | struct timeval tval; 11 | 12 | for ( ; ; ) { 13 | tval.tv_sec = nusecs / 1000000; 14 | tval.tv_usec = nusecs % 1000000; 15 | if (select(0, NULL, NULL, NULL, &tval) == 0) 16 | break; /* all OK */ 17 | /* 18 | * Note than on an interrupted system call (i.e, SIGIO) there's not 19 | * much we can do, since the timeval{} isn't updated with the time 20 | * remaining. We could obtain the clock time before the call, and 21 | * then obtain the clock time here, subtracting them to determine 22 | * how long select() blocked before it was interrupted, but that 23 | * seems like too much work :-) 24 | */ 25 | if (errno == EINTR) 26 | continue; 27 | err_sys("sleep_us: select error"); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /sock/sock.in: -------------------------------------------------------------------------------- 1 | 1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890 2 | -------------------------------------------------------------------------------- /sock/strerror.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | extern const char *const sys_errlist[]; 4 | extern int sys_nerr; 5 | 6 | char * 7 | strerror(int error) 8 | { 9 | static char mesg[30]; 10 | 11 | if (error >= 0 && error <= sys_nerr) 12 | return(sys_errlist[error]); 13 | 14 | snprintf(mesg, sizeof(mesg), "Unknown error (%d)", error); 15 | return(mesg); 16 | } 17 | -------------------------------------------------------------------------------- /sock/writen.c: -------------------------------------------------------------------------------- 1 | #include "ourhdr.h" 2 | 3 | ssize_t /* Write "n" bytes to a descriptor. */ 4 | writen(int fd, const void *vptr, size_t n) 5 | { 6 | size_t nleft, nwritten; 7 | const char *ptr; 8 | 9 | ptr = vptr; /* can't do pointer arithmetic on void* */ 10 | nleft = n; 11 | while (nleft > 0) { 12 | if ( (nwritten = write(fd, ptr, nleft)) <= 0) 13 | return(nwritten); /* error */ 14 | 15 | nleft -= nwritten; 16 | ptr += nwritten; 17 | } 18 | return(n); 19 | } 20 | -------------------------------------------------------------------------------- /sockopt/Makefile: -------------------------------------------------------------------------------- 1 | include ../Make.defines 2 | 3 | PROGS = checkopts prdefaults rcvbuf rcvbufset sockopt 4 | 5 | all: ${PROGS} 6 | 7 | sockopt: sockopt.o 8 | ${CC} ${CFLAGS} -o $@ sockopt.o ${LIBS} 9 | 10 | checkopts: checkopts.o 11 | ${CC} ${CFLAGS} -o $@ checkopts.o ${LIBS} 12 | 13 | prdefaults: prdefaults.o 14 | ${CC} ${CFLAGS} -o $@ prdefaults.o ${LIBS} 15 | 16 | rcvbuf: rcvbuf.o 17 | ${CC} ${CFLAGS} -o $@ rcvbuf.o ${LIBS} 18 | 19 | rcvbufset: rcvbufset.o 20 | ${CC} ${CFLAGS} -o $@ rcvbufset.o ${LIBS} 21 | 22 | clean: 23 | rm -f ${PROGS} ${CLEANFILES} 24 | -------------------------------------------------------------------------------- /sockopt/sockopt.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | #include /* for TCP_MAXSEG value */ 3 | 4 | int 5 | main(int argc, char **argv) 6 | { 7 | int sockfd, mss, sendbuff; 8 | socklen_t optlen; 9 | 10 | sockfd = Socket(AF_INET, SOCK_STREAM, 0); 11 | 12 | /* Fetch and print the TCP maximum segment size. */ 13 | optlen = sizeof(mss); 14 | Getsockopt(sockfd, IPPROTO_TCP, TCP_MAXSEG, &mss, &optlen); 15 | printf("TCP mss = %d\n", mss); 16 | 17 | /* Set the send buffer size, then fetch it and print its value. */ 18 | sendbuff = 65536; 19 | Setsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, &sendbuff, sizeof(sendbuff)); 20 | 21 | optlen = sizeof(sendbuff); 22 | Getsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, &sendbuff, &optlen); 23 | printf("send buffer size = %d\n", sendbuff); 24 | exit(0); 25 | } 26 | -------------------------------------------------------------------------------- /ssntp/Makefile: -------------------------------------------------------------------------------- 1 | include ../Make.defines 2 | 3 | PROGS = ssntp 4 | 5 | all: ${PROGS} 6 | 7 | ssntp: main.o sntp_proc.o 8 | ${CC} ${CFLAGS} -o $@ main.o sntp_proc.o ${LIBS} 9 | 10 | clean: 11 | rm -f ${PROGS} ${CLEANFILES} 12 | -------------------------------------------------------------------------------- /ssntp/ntp.h: -------------------------------------------------------------------------------- 1 | #define JAN_1970 2208988800UL /* 1970 - 1900 in seconds */ 2 | 3 | struct l_fixedpt { /* 64-bit fixed-point */ 4 | uint32_t int_part; 5 | uint32_t fraction; 6 | }; 7 | 8 | struct s_fixedpt { /* 32-bit fixed-point */ 9 | uint16_t int_part; 10 | uint16_t fraction; 11 | }; 12 | 13 | struct ntpdata { /* NTP header */ 14 | u_char status; 15 | u_char stratum; 16 | u_char ppoll; 17 | int precision:8; 18 | struct s_fixedpt distance; 19 | struct s_fixedpt dispersion; 20 | uint32_t refid; 21 | struct l_fixedpt reftime; 22 | struct l_fixedpt org; 23 | struct l_fixedpt rec; 24 | struct l_fixedpt xmt; 25 | }; 26 | 27 | #define VERSION_MASK 0x38 28 | #define MODE_MASK 0x07 29 | 30 | #define MODE_CLIENT 3 31 | #define MODE_SERVER 4 32 | #define MODE_BROADCAST 5 33 | -------------------------------------------------------------------------------- /ssntp/sntp.h: -------------------------------------------------------------------------------- 1 | #include "unpifi.h" 2 | #include "ntp.h" 3 | 4 | void sntp_proc(char *, ssize_t, struct timeval *); 5 | -------------------------------------------------------------------------------- /streams/Makefile: -------------------------------------------------------------------------------- 1 | include ../Make.defines 2 | 3 | PROGS = strlist_sock strlist_xti tpi_daytime 4 | 5 | all: ${PROGS} 6 | 7 | strlist_sock: strlist_sock.o 8 | ${CC} ${CFLAGS} -o $@ strlist_sock.o ${LIBS_XTI} 9 | 10 | strlist_xti: strlist_xti.o 11 | ${CC} ${CFLAGS} -o $@ strlist_xti.o ${LIBS_XTI} 12 | 13 | tpi_daytime: tpi_daytime.o tpi_bind.o tpi_connect.o tpi_read.o tpi_close.o 14 | ${CC} ${CFLAGS} -o $@ tpi_daytime.o tpi_bind.o tpi_connect.o \ 15 | tpi_read.o tpi_close.o ${LIBS_XTI} 16 | 17 | clean: 18 | rm -f ${PROGS} ${CLEANFILES} 19 | -------------------------------------------------------------------------------- /streams/stream_dg/Makefile: -------------------------------------------------------------------------------- 1 | all: client server 2 | 3 | client: client.o net_stream.o 4 | cc client.o net_stream.o -o client -lnsl 5 | 6 | server: server.o net_stream.o 7 | cc server.o net_stream.o -o server -lnsl 8 | -------------------------------------------------------------------------------- /streams/strlist_sock.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | #include 3 | 4 | int 5 | main(int argc, char *argv[]) 6 | { 7 | int fd, i, nmods; 8 | struct str_list list; 9 | 10 | if (argc != 2) 11 | err_quit("usage: a.out { tcp | udp }"); 12 | 13 | fd = Socket(AF_INET, (strcmp(argv[1], "tcp") == 0) 14 | ? SOCK_STREAM : SOCK_DGRAM, 0); 15 | if (isastream(fd) == 0) 16 | err_quit("%s is not a stream", argv[1]); 17 | 18 | list.sl_nmods = nmods = Ioctl(fd, I_LIST, (void *) 0); 19 | printf("%d modules\n", nmods); 20 | list.sl_modlist = Calloc(nmods, sizeof(struct str_mlist)); 21 | 22 | Ioctl(fd, I_LIST, &list); 23 | 24 | for (i = 1; i <= nmods; i++) 25 | printf(" %s: %s\n", (i == nmods) ? "driver" : "module", 26 | list.sl_modlist++); 27 | exit(0); 28 | } 29 | -------------------------------------------------------------------------------- /streams/strlist_xti.c: -------------------------------------------------------------------------------- 1 | #include "unpxti.h" 2 | #include 3 | 4 | int 5 | main(int argc, char *argv[]) 6 | { 7 | int fd, i, nmods; 8 | struct str_list list; 9 | 10 | if (argc != 2) 11 | err_quit("usage: a.out "); 12 | 13 | fd = T_open(argv[1], O_RDWR, NULL); 14 | if (isastream(fd) == 0) 15 | err_quit("%s is not a stream", argv[1]); 16 | 17 | list.sl_nmods = nmods = Ioctl(fd, I_LIST, (void *) 0); 18 | printf("%d modules\n", nmods); 19 | list.sl_modlist = Calloc(nmods, sizeof(struct str_mlist)); 20 | 21 | Ioctl(fd, I_LIST, &list); 22 | 23 | for (i = 1; i <= nmods; i++) 24 | printf(" %s: %s\n", (i == nmods) ? "driver" : "module", 25 | list.sl_modlist++); 26 | exit(0); 27 | } 28 | -------------------------------------------------------------------------------- /streams/tpi_close.c: -------------------------------------------------------------------------------- 1 | #include "tpi_daytime.h" 2 | 3 | void 4 | tpi_close(int fd) 5 | { 6 | struct T_ordrel_req ordrel_req; 7 | struct strbuf ctlbuf; 8 | 9 | ordrel_req.PRIM_type = T_ORDREL_REQ; 10 | 11 | ctlbuf.len = sizeof(struct T_ordrel_req); 12 | ctlbuf.buf = (char *) &ordrel_req; 13 | Putmsg(fd, &ctlbuf, NULL, 0); 14 | 15 | Close(fd); 16 | } 17 | -------------------------------------------------------------------------------- /streams/tpi_daytime.h: -------------------------------------------------------------------------------- 1 | #include "unpxti.h" 2 | #include 3 | #include 4 | 5 | void tpi_bind(int, const void *, size_t); 6 | void tpi_connect(int, const void *, size_t); 7 | ssize_t tpi_read(int, void *, size_t); 8 | void tpi_close(int); 9 | -------------------------------------------------------------------------------- /streams/tpi_read.c: -------------------------------------------------------------------------------- 1 | #include "tpi_daytime.h" 2 | 3 | ssize_t 4 | tpi_read(int fd, void *buf, size_t len) 5 | { 6 | struct strbuf ctlbuf; 7 | struct strbuf datbuf; 8 | union T_primitives rcvbuf; 9 | int flags; 10 | 11 | ctlbuf.maxlen = sizeof(union T_primitives); 12 | ctlbuf.buf = (char *) &rcvbuf; 13 | 14 | datbuf.maxlen = len; 15 | datbuf.buf = buf; 16 | datbuf.len = 0; 17 | 18 | flags = 0; 19 | Getmsg(fd, &ctlbuf, &datbuf, &flags); 20 | 21 | if (ctlbuf.len >= (int) sizeof(long)) { 22 | if (rcvbuf.type == T_DATA_IND) 23 | return(datbuf.len); 24 | else if (rcvbuf.type == T_ORDREL_IND) 25 | return(0); 26 | else 27 | err_quit("tpi_read: unexpected type %d", rcvbuf.type); 28 | } else if (ctlbuf.len == -1) 29 | return(datbuf.len); 30 | else 31 | err_quit("tpi_read: bad length from getmsg"); 32 | } 33 | -------------------------------------------------------------------------------- /tcpcliserv/sigchldwait.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | sig_chld(int signo) 5 | { 6 | pid_t pid; 7 | int stat; 8 | 9 | pid = wait(&stat); 10 | printf("child %d terminated\n", pid); 11 | return; 12 | } 13 | -------------------------------------------------------------------------------- /tcpcliserv/sigchldwaitpid.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | sig_chld(int signo){ 5 | pid_t pid; 6 | int stat; 7 | 8 | // constant WNOHANG tells waitpid not to block if there are running children that 9 | // have not yet terminated. 10 | while ( (pid = waitpid(-1, &stat, WNOHANG)) > 0) 11 | printf("child %d terminated\n", pid); 12 | return; 13 | } 14 | -------------------------------------------------------------------------------- /tcpcliserv/str_cli08.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | str_cli(FILE *fp, int sockfd) 5 | { 6 | char sendline[MAXLINE], recvline[MAXLINE]; 7 | 8 | while (Fgets(sendline, MAXLINE, fp) != NULL) { 9 | 10 | Writen(sockfd, sendline, strlen(sendline)); 11 | 12 | if (Readline(sockfd, recvline, MAXLINE) == 0) 13 | err_quit("str_cli: server terminated prematurely"); 14 | 15 | Fputs(recvline, stdout); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /tcpcliserv/str_cli09.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | #include "sum.h" 3 | 4 | void 5 | str_cli(FILE *fp, int sockfd) 6 | { 7 | char sendline[MAXLINE]; 8 | struct args args; 9 | struct result result; 10 | 11 | while (Fgets(sendline, MAXLINE, fp) != NULL) { 12 | 13 | if (sscanf(sendline, "%ld%ld", &args.arg1, &args.arg2) != 2) { 14 | printf("invalid input: %s", sendline); 15 | continue; 16 | } 17 | Writen(sockfd, &args, sizeof(args)); 18 | 19 | if (Readn(sockfd, &result, sizeof(result)) == 0) 20 | err_quit("str_cli: server terminated prematurely"); 21 | 22 | printf("%ld\n", result.sum); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /tcpcliserv/str_cli11.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | str_cli(FILE *fp, int sockfd) 5 | { 6 | char sendline[MAXLINE], recvline[MAXLINE]; 7 | 8 | while (Fgets(sendline, MAXLINE, fp) != NULL) { 9 | 10 | Writen(sockfd, sendline, 1); 11 | sleep(1); 12 | Writen(sockfd, sendline+1, strlen(sendline)-1); 13 | 14 | if (Readline(sockfd, recvline, MAXLINE) == 0) 15 | err_quit("str_cli: server terminated prematurely"); 16 | 17 | Fputs(recvline, stdout); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /tcpcliserv/str_echo08.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | str_echo(int sockfd) 5 | { 6 | long arg1, arg2; 7 | ssize_t n; 8 | char line[MAXLINE]; 9 | 10 | for ( ; ; ) { 11 | if ( (n = Readline(sockfd, line, MAXLINE)) == 0) 12 | return; /* connection closed by other end */ 13 | 14 | if (sscanf(line, "%ld%ld", &arg1, &arg2) == 2) 15 | snprintf(line, sizeof(line), "%ld\n", arg1 + arg2); 16 | else 17 | snprintf(line, sizeof(line), "input error\n"); 18 | 19 | n = strlen(line); 20 | Writen(sockfd, line, n); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /tcpcliserv/str_echo09.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | #include "sum.h" 3 | 4 | void 5 | str_echo(int sockfd) 6 | { 7 | ssize_t n; 8 | struct args args; 9 | struct result result; 10 | 11 | for ( ; ; ) { 12 | if ( (n = Readn(sockfd, &args, sizeof(args))) == 0) 13 | return; /* connection closed by other end */ 14 | 15 | result.sum = args.arg1 + args.arg2; 16 | Writen(sockfd, &result, sizeof(result)); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /tcpcliserv/sum.h: -------------------------------------------------------------------------------- 1 | struct args { 2 | long arg1; 3 | long arg2; 4 | }; 5 | 6 | struct result { 7 | long sum; 8 | }; 9 | -------------------------------------------------------------------------------- /tcpcliserv/tcpcli01.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: tcpcli "); 11 | 12 | sockfd = Socket(AF_INET, SOCK_STREAM, 0); 13 | 14 | bzero(&servaddr, sizeof(servaddr)); 15 | servaddr.sin_family = AF_INET; 16 | servaddr.sin_port = htons(SERV_PORT); 17 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 18 | 19 | Connect(sockfd, (SA *) &servaddr, sizeof(servaddr)); 20 | 21 | str_cli(stdin, sockfd); /* do it all */ 22 | 23 | exit(0); 24 | } 25 | -------------------------------------------------------------------------------- /tcpcliserv/tcpcli04.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int i, sockfd[5]; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: tcpcli "); 11 | 12 | for (i = 0; i < 5; i++) { 13 | sockfd[i] = Socket(AF_INET, SOCK_STREAM, 0); 14 | 15 | bzero(&servaddr, sizeof(servaddr)); 16 | servaddr.sin_family = AF_INET; 17 | servaddr.sin_port = htons(SERV_PORT); 18 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 19 | 20 | Connect(sockfd[i], (SA *) &servaddr, sizeof(servaddr)); 21 | } 22 | 23 | str_cli(stdin, sockfd[0]); /* do it all */ 24 | 25 | exit(0); 26 | } 27 | -------------------------------------------------------------------------------- /tcpcliserv/tcpcli05.c: -------------------------------------------------------------------------------- 1 | /* Use standard echo server; baseline measurements for nonblocking version */ 2 | #include "unp.h" 3 | 4 | int 5 | main(int argc, char **argv) 6 | { 7 | int sockfd; 8 | struct sockaddr_in servaddr; 9 | 10 | if (argc != 2) 11 | err_quit("usage: tcpcli "); 12 | 13 | sockfd = Socket(AF_INET, SOCK_STREAM, 0); 14 | 15 | bzero(&servaddr, sizeof(servaddr)); 16 | servaddr.sin_family = AF_INET; 17 | servaddr.sin_port = htons(7); 18 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 19 | 20 | Connect(sockfd, (SA *) &servaddr, sizeof(servaddr)); 21 | 22 | str_cli(stdin, sockfd); /* do it all */ 23 | 24 | exit(0); 25 | } 26 | -------------------------------------------------------------------------------- /tcpcliserv/tcpcli06.c: -------------------------------------------------------------------------------- 1 | /* Test version of client that sends one line without a newline, 2 | to break tcpservselect01.c */ 3 | 4 | #include "unp.h" 5 | 6 | int 7 | main(int argc, char **argv) 8 | { 9 | int sockfd; 10 | struct sockaddr_in servaddr; 11 | 12 | if (argc != 2) 13 | err_quit("usage: tcpcli "); 14 | 15 | sockfd = Socket(AF_INET, SOCK_STREAM, 0); 16 | 17 | bzero(&servaddr, sizeof(servaddr)); 18 | servaddr.sin_family = AF_INET; 19 | servaddr.sin_port = htons(SERV_PORT); 20 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 21 | 22 | Connect(sockfd, (SA *) &servaddr, sizeof(servaddr)); 23 | 24 | Writen(sockfd, "foo", 3); /* no newline */ 25 | sleep(30); 26 | 27 | exit(0); 28 | } 29 | -------------------------------------------------------------------------------- /tcpcliserv/tcpcli08.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: tcpcli "); 11 | 12 | sockfd = Socket(AF_INET, SOCK_STREAM, 0); 13 | 14 | bzero(&servaddr, sizeof(servaddr)); 15 | servaddr.sin_family = AF_INET; 16 | servaddr.sin_port = htons(SERV_PORT); 17 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 18 | 19 | Connect(sockfd, (SA *) &servaddr, sizeof(servaddr)); 20 | 21 | str_cli(stdin, sockfd); /* do it all */ 22 | 23 | exit(0); 24 | } 25 | -------------------------------------------------------------------------------- /tcpcliserv/tcpcli09.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: tcpcli "); 11 | 12 | sockfd = Socket(AF_INET, SOCK_STREAM, 0); 13 | 14 | bzero(&servaddr, sizeof(servaddr)); 15 | servaddr.sin_family = AF_INET; 16 | servaddr.sin_port = htons(SERV_PORT); 17 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 18 | 19 | Connect(sockfd, (SA *) &servaddr, sizeof(servaddr)); 20 | 21 | str_cli(stdin, sockfd); /* do it all */ 22 | 23 | exit(0); 24 | } 25 | -------------------------------------------------------------------------------- /tcpcliserv/tcpcli10.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct linger ling; 8 | struct sockaddr_in servaddr; 9 | 10 | if (argc != 2) 11 | err_quit("usage: tcpcli "); 12 | 13 | sockfd = Socket(AF_INET, SOCK_STREAM, 0); 14 | 15 | bzero(&servaddr, sizeof(servaddr)); 16 | servaddr.sin_family = AF_INET; 17 | servaddr.sin_port = htons(SERV_PORT); 18 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 19 | 20 | Connect(sockfd, (SA *) &servaddr, sizeof(servaddr)); 21 | 22 | str_cli(stdin, sockfd); /* do it all */ 23 | 24 | ling.l_onoff = 1; 25 | ling.l_linger = 0; 26 | Setsockopt(sockfd, SOL_SOCKET, SO_LINGER, &ling, sizeof(ling)); 27 | 28 | exit(0); 29 | } 30 | -------------------------------------------------------------------------------- /tcpcliserv/tcpcli11.c: -------------------------------------------------------------------------------- 1 | /* Use standard echo server; baseline measurements for nonblocking version */ 2 | #include "unp.h" 3 | 4 | int 5 | main(int argc, char **argv) 6 | { 7 | int sockfd; 8 | struct sockaddr_in servaddr; 9 | 10 | if (argc != 2) 11 | err_quit("usage: tcpcli "); 12 | 13 | sockfd = Socket(AF_INET, SOCK_STREAM, 0); 14 | 15 | bzero(&servaddr, sizeof(servaddr)); 16 | servaddr.sin_family = AF_INET; 17 | servaddr.sin_port = htons(7); 18 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 19 | 20 | Connect(sockfd, (SA *) &servaddr, sizeof(servaddr)); 21 | 22 | str_cli(stdin, sockfd); /* do it all */ 23 | 24 | exit(0); 25 | } 26 | -------------------------------------------------------------------------------- /tcpcliserv/tcpserv01.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int listenfd, connfd; 7 | pid_t childpid; 8 | socklen_t clilen; 9 | struct sockaddr_in cliaddr, servaddr; 10 | 11 | listenfd = Socket(AF_INET, SOCK_STREAM, 0); 12 | 13 | bzero(&servaddr, sizeof(servaddr)); 14 | servaddr.sin_family = AF_INET; 15 | servaddr.sin_addr.s_addr = htonl(INADDR_ANY); 16 | servaddr.sin_port = htons(SERV_PORT); 17 | 18 | Bind(listenfd, (SA *) &servaddr, sizeof(servaddr)); 19 | 20 | Listen(listenfd, LISTENQ); 21 | 22 | for ( ; ; ) { 23 | clilen = sizeof(cliaddr); 24 | connfd = Accept(listenfd, (SA *) &cliaddr, &clilen); 25 | 26 | if ( (childpid = Fork()) == 0) { /* child process */ 27 | Close(listenfd); /* close listening socket */ 28 | str_echo(connfd); /* process the request */ 29 | exit(0); 30 | } 31 | Close(connfd); /* parent closes connected socket */ 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /tcpcliserv/tsigpipe.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | sig_pipe(int signo) 5 | { 6 | printf("SIGPIPE received\n"); 7 | return; 8 | } 9 | 10 | int 11 | main(int argc, char **argv) 12 | { 13 | int sockfd; 14 | struct sockaddr_in servaddr; 15 | 16 | if (argc != 2) 17 | err_quit("usage: tcpcli "); 18 | 19 | sockfd = Socket(AF_INET, SOCK_STREAM, 0); 20 | 21 | bzero(&servaddr, sizeof(servaddr)); 22 | servaddr.sin_family = AF_INET; 23 | servaddr.sin_port = htons(13); /* daytime server */ 24 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 25 | 26 | Signal(SIGPIPE, sig_pipe); 27 | 28 | Connect(sockfd, (SA *) &servaddr, sizeof(servaddr)); 29 | 30 | sleep(2); 31 | Write(sockfd, "hello", 5); 32 | sleep(2); 33 | Write(sockfd, "world", 5); 34 | 35 | exit(0); 36 | } 37 | -------------------------------------------------------------------------------- /test/accept_eintr.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | /* Let's see if accept() is automatically restarted by the implementation. */ 4 | 5 | void 6 | sig_int(int signo) 7 | { 8 | printf("received SIGINT\n"); 9 | return; 10 | } 11 | 12 | int 13 | main(int argc, char **argv) 14 | { 15 | int listenfd, connfd; 16 | socklen_t clilen; 17 | struct sockaddr_in cliaddr, servaddr; 18 | 19 | listenfd = Socket(AF_INET, SOCK_STREAM, 0); 20 | 21 | bzero(&servaddr, sizeof(servaddr)); 22 | servaddr.sin_family = AF_INET; 23 | servaddr.sin_addr.s_addr = htonl(INADDR_ANY); 24 | servaddr.sin_port = htons(SERV_PORT); 25 | 26 | Bind(listenfd, (SA *) &servaddr, sizeof(servaddr)); 27 | 28 | Listen(listenfd, LISTENQ); 29 | 30 | Signal(SIGINT, sig_int); /* sets SA_RESTART */ 31 | 32 | for ( ; ; ) { 33 | clilen = sizeof(cliaddr); 34 | connfd = Accept(listenfd, (SA *) &cliaddr, &clilen); 35 | /* error from Accept() if not restarted */ 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /test/readline.h: -------------------------------------------------------------------------------- 1 | typedef struct { 2 | int read_fd; /* caller's descriptor to read from */ 3 | char *read_ptr; /* caller's buffer to read into */ 4 | size_t read_maxlen; /* max #bytes to read */ 5 | /* next three are used internally by the function */ 6 | int rl_cnt; /* initialize to 0 */ 7 | char *rl_bufptr; /* initialize to rl_buf */ 8 | char rl_buf[MAXLINE]; 9 | } Rline; 10 | 11 | void readline_rinit(int, void *, size_t, Rline *); 12 | ssize_t readline_r(Rline *); 13 | -------------------------------------------------------------------------------- /test/readline1.c: -------------------------------------------------------------------------------- 1 | /* include readline */ 2 | #include "unp.h" 3 | 4 | /* PAINFULLY SLOW VERSION -- example only */ 5 | ssize_t 6 | readline(int fd, void *vptr, size_t maxlen) 7 | { 8 | ssize_t n, rc; 9 | char c, *ptr; 10 | 11 | ptr = vptr; 12 | for (n = 1; n < maxlen; n++) { 13 | again: 14 | if ( (rc = read(fd, &c, 1)) == 1) { 15 | *ptr++ = c; 16 | if (c == '\n') 17 | break; /* newline is stored, like fgets() */ 18 | } else if (rc == 0) { 19 | *ptr = 0; 20 | return(n - 1); /* EOF, n - 1 bytes were read */ 21 | } else { 22 | if (errno == EINTR) 23 | goto again; 24 | return(-1); /* error, errno set by read() */ 25 | } 26 | } 27 | 28 | *ptr = 0; /* null terminate like fgets() */ 29 | return(n); 30 | } 31 | /* end readline */ 32 | 33 | ssize_t 34 | Readline(int fd, void *ptr, size_t maxlen) 35 | { 36 | ssize_t n; 37 | 38 | if ( (n = readline(fd, ptr, maxlen)) < 0) 39 | err_sys("readline error"); 40 | return(n); 41 | } 42 | -------------------------------------------------------------------------------- /test/test.h: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | /* globals */ 4 | extern struct sockaddr_in servaddr, cliaddr; 5 | extern char buff[8192]; 6 | extern int verbose; 7 | 8 | int TcpSockByAddr(char *, int); 9 | int UdpSockByAddr(char *, int); 10 | int UdpConnSockByAddr(char *, int); 11 | -------------------------------------------------------------------------------- /test/tisfdtype.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | main() 4 | { 5 | int tcpsock, udpsock; 6 | 7 | printf("stdin: %d\n", Isfdtype(STDIN_FILENO, S_IFSOCK)); 8 | printf("stdout: %d\n", Isfdtype(STDOUT_FILENO, S_IFSOCK)); 9 | printf("stderr: %d\n", Isfdtype(STDERR_FILENO, S_IFSOCK)); 10 | 11 | tcpsock = Socket(AF_INET, SOCK_STREAM, 0); 12 | printf("TCP socket: %d\n", Isfdtype(tcpsock, S_IFSOCK)); 13 | 14 | udpsock = Socket(AF_INET, SOCK_DGRAM, 0); 15 | printf("UDP socket: %d\n", Isfdtype(udpsock, S_IFSOCK)); 16 | 17 | exit(0); 18 | } 19 | -------------------------------------------------------------------------------- /test/treadline1.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int count = 0; 7 | ssize_t n; 8 | char recvline[MAXLINE]; 9 | 10 | while ( ( n = readline(STDIN_FILENO, recvline, MAXLINE)) > 0) 11 | count++; 12 | printf("%d lines\n", count); 13 | } 14 | -------------------------------------------------------------------------------- /test/treadline2.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int count = 0; 7 | ssize_t n; 8 | char recvline[MAXLINE]; 9 | 10 | while ( ( n = readline(STDIN_FILENO, recvline, MAXLINE)) > 0) 11 | count++; 12 | printf("%d lines\n", count); 13 | } 14 | -------------------------------------------------------------------------------- /test/treadline3.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | #include "readline.h" 3 | 4 | int 5 | main(int argc, char **argv) 6 | { 7 | int count = 0; 8 | ssize_t n; 9 | char recvline[MAXLINE]; 10 | Rline rline; 11 | 12 | readline_rinit(STDIN_FILENO, recvline, MAXLINE, &rline); 13 | while ( (n = readline_r(&rline)) > 0) 14 | count++; 15 | printf("%d lines\n", count); 16 | } 17 | -------------------------------------------------------------------------------- /test/tshutdown.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | #define BUFF 100000 4 | char buff[BUFF]; 5 | 6 | int 7 | main(int argc, char **argv) 8 | { 9 | int sockfd, nbytes; 10 | ssize_t n; 11 | 12 | if (argc != 3) 13 | err_quit("usage: tshutdown "); 14 | 15 | sockfd = Tcp_connect(argv[1], argv[2]); 16 | fprintf(stderr, "connected\n"); 17 | 18 | while ( (n = Read(STDIN_FILENO, buff, BUFF)) > 0) { 19 | Writen(sockfd, buff, n); 20 | } 21 | Close(STDIN_FILENO); 22 | /* Shutdown(sockfd, SHUT_WR); */ 23 | 24 | nbytes = 0; 25 | while ( (n = Read(sockfd, buff, BUFF)) > 0) { 26 | /* fprintf(stderr, "read %d bytes from socket\n", n); */ 27 | Write(STDOUT_FILENO, buff, n); 28 | nbytes += n; 29 | } 30 | fprintf(stderr, "total: %d bytes read from socket\n", nbytes); 31 | Close(STDOUT_FILENO); 32 | 33 | exit(0); 34 | } 35 | -------------------------------------------------------------------------------- /test/tsnprintf.c: -------------------------------------------------------------------------------- 1 | /* 2 | * If your system does not provide snprintf(), this program will compile 3 | * but will have an undefined error from the linker. 4 | * 5 | * If you are using the lib/snprintf.c function that is supplied for 6 | * systems without snprintf(), you should get an error output from our 7 | * library function. 8 | * 9 | * If your system provides the function, and it works, there should be 10 | * no output. 11 | */ 12 | 13 | #include "unp.h" 14 | 15 | int 16 | main(int argc, char **argv) 17 | { 18 | int n; 19 | char buf[1024]; 20 | 21 | n = snprintf(buf, 4, "%d", 9999); 22 | if (n > 3) 23 | printf("error: snprintf overflowed buffer, n = %d\n", n); 24 | exit(0); 25 | } 26 | -------------------------------------------------------------------------------- /threads/doit.1: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | case $# in 4 | 1) break ;; 5 | *) echo "one argument (#simultaneous connections) required" 1>&2 6 | exit 1 ;; 7 | esac 8 | 9 | time ./web03 $1 192.207.117.2 / \ 10 | /img/logo/awl_logo_blue_50x40.gif \ 11 | /img/a_world_of_learning.gif \ 12 | /img/toolbar_soptions.gif \ 13 | /img/toolbar_purchase.gif \ 14 | /img/toolbar_feedback.gif \ 15 | /img/toolbar_top_hilite.gif \ 16 | /img/toolbar_qsearch.gif \ 17 | /img/blue_dot.gif \ 18 | /img/logo/pearson_logo_50.gif 19 | -------------------------------------------------------------------------------- /threads/doit.2: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | 3 | ClientP=/nfs/kohala/home/rstevens/doc/unp/src/tcpcliserv/tcpcli01 # client prog 4 | ServerH="206.62.226.33" # server host 5 | Infile=/usr/share/misc/zipcodes # big BSD/OS text file 6 | 7 | $ClientP $ServerH < $Infile > temp.1 & 8 | $ClientP $ServerH < $Infile > temp.2 & 9 | $ClientP $ServerH < $Infile > temp.3 & 10 | # $ClientP $ServerH < $Infile > temp.4 & 11 | # $ClientP $ServerH < $Infile > temp.5 & 12 | # $ClientP $ServerH < $Infile > temp.6 & 13 | # $ClientP $ServerH < $Infile > temp.7 & 14 | # $ClientP $ServerH < $Infile > temp.8 & 15 | # $ClientP $ServerH < $Infile > temp.9 & 16 | 17 | wait 18 | -------------------------------------------------------------------------------- /threads/example01.c: -------------------------------------------------------------------------------- 1 | #include "unpthread.h" 2 | 3 | #define NLOOP 5000 4 | 5 | int counter; /* incremented by threads */ 6 | 7 | void *doit(void *); 8 | 9 | int 10 | main(int argc, char **argv) 11 | { 12 | pthread_t tidA, tidB; 13 | 14 | Pthread_create(&tidA, NULL, &doit, NULL); 15 | Pthread_create(&tidB, NULL, &doit, NULL); 16 | 17 | /* 4wait for both threads to terminate */ 18 | Pthread_join(tidA, NULL); 19 | Pthread_join(tidB, NULL); 20 | 21 | exit(0); 22 | } 23 | 24 | void * 25 | doit(void *vptr) 26 | { 27 | int i, val; 28 | 29 | /* 30 | * Each thread fetches, prints, and increments the counter NLOOP times. 31 | * The value of the counter should increase monotonically. 32 | */ 33 | 34 | for (i = 0; i < NLOOP; i++) { 35 | val = counter; 36 | printf("%d: %d\n", pthread_self(), val + 1); 37 | counter = val + 1; 38 | } 39 | 40 | return(NULL); 41 | } 42 | -------------------------------------------------------------------------------- /threads/strclithread.c: -------------------------------------------------------------------------------- 1 | #include "unpthread.h" 2 | 3 | void *copyto(void *); 4 | 5 | static int sockfd; /* global for both threads to access */ 6 | static FILE *fp; 7 | 8 | void 9 | str_cli(FILE *fp_arg, int sockfd_arg) 10 | { 11 | char recvline[MAXLINE]; 12 | pthread_t tid; 13 | 14 | sockfd = sockfd_arg; /* copy arguments to externals */ 15 | fp = fp_arg; 16 | 17 | Pthread_create(&tid, NULL, copyto, NULL); 18 | 19 | while (Readline(sockfd, recvline, MAXLINE) > 0) 20 | Fputs(recvline, stdout); 21 | } 22 | 23 | void * 24 | copyto(void *arg) 25 | { 26 | char sendline[MAXLINE]; 27 | 28 | while (Fgets(sendline, MAXLINE, fp) != NULL) 29 | Writen(sockfd, sendline, strlen(sendline)); 30 | 31 | Shutdown(sockfd, SHUT_WR); /* EOF on stdin, send FIN */ 32 | 33 | return(NULL); 34 | /* 4return (i.e., thread terminates) when EOF on stdin */ 35 | } 36 | -------------------------------------------------------------------------------- /threads/strclithread2.c: -------------------------------------------------------------------------------- 1 | #include "unpthread.h" 2 | 3 | void *copyto(void *); 4 | 5 | static int sockfd; 6 | static FILE *fp; 7 | static int done; 8 | 9 | void 10 | str_cli(FILE *fp_arg, int sockfd_arg) 11 | { 12 | char recvline[MAXLINE]; 13 | pthread_t tid; 14 | 15 | sockfd = sockfd_arg; /* copy arguments to externals */ 16 | fp = fp_arg; 17 | 18 | Pthread_create(&tid, NULL, copyto, NULL); 19 | 20 | while (Readline(sockfd, recvline, MAXLINE) > 0) 21 | Fputs(recvline, stdout); 22 | 23 | if (done == 0) 24 | err_quit("server terminated prematurely"); 25 | } 26 | 27 | void * 28 | copyto(void *arg) 29 | { 30 | char sendline[MAXLINE]; 31 | 32 | while (Fgets(sendline, MAXLINE, fp) != NULL) 33 | Writen(sockfd, sendline, strlen(sendline)); 34 | 35 | Shutdown(sockfd, SHUT_WR); /* EOF on stdin, send FIN */ 36 | 37 | done = 1; 38 | return(NULL); 39 | /* return (i.e., thread terminates) when end-of-file on stdin */ 40 | } 41 | -------------------------------------------------------------------------------- /threads/tcpcli01.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | 8 | if (argc != 3) 9 | err_quit("usage: tcpcli "); 10 | 11 | sockfd = Tcp_connect(argv[1], argv[2]); 12 | 13 | str_cli(stdin, sockfd); /* do it all */ 14 | 15 | exit(0); 16 | } 17 | -------------------------------------------------------------------------------- /threads/tcpcli02.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | 8 | if (argc != 3) 9 | err_quit("usage: tcpcli "); 10 | 11 | sockfd = Tcp_connect(argv[1], argv[2]); 12 | 13 | str_cli(stdin, sockfd); /* do it all */ 14 | 15 | exit(0); 16 | } 17 | -------------------------------------------------------------------------------- /threads/tcpserv01.c: -------------------------------------------------------------------------------- 1 | #include "unpthread.h" 2 | 3 | static void *doit(void *); /* each thread executes this function */ 4 | 5 | int 6 | main(int argc, char **argv) 7 | { 8 | int listenfd, connfd; 9 | pthread_t tid; 10 | socklen_t addrlen, len; 11 | struct sockaddr *cliaddr; 12 | 13 | if (argc == 2) 14 | listenfd = Tcp_listen(NULL, argv[1], &addrlen); 15 | else if (argc == 3) 16 | listenfd = Tcp_listen(argv[1], argv[2], &addrlen); 17 | else 18 | err_quit("usage: tcpserv01 [ ] "); 19 | 20 | cliaddr = Malloc(addrlen); 21 | 22 | for ( ; ; ) { 23 | len = addrlen; 24 | connfd = Accept(listenfd, cliaddr, &len); 25 | Pthread_create(&tid, NULL, &doit, (void *) connfd); 26 | } 27 | } 28 | 29 | static void * 30 | doit(void *arg) 31 | { 32 | Pthread_detach(pthread_self()); 33 | str_echo((int) arg); /* same function as before */ 34 | Close((int) arg); /* done with connected socket */ 35 | return(NULL); 36 | } 37 | -------------------------------------------------------------------------------- /threads/test01.c: -------------------------------------------------------------------------------- 1 | #include "unpthread.h" 2 | 3 | void * 4 | myfunc(void *ptr) 5 | { 6 | pause(); 7 | } 8 | 9 | int 10 | main(int argc, char **argv) 11 | { 12 | pthread_t tid; 13 | int n; 14 | 15 | /* Let's see what the return value is and what errno is after a error. */ 16 | for ( ; ; ) { 17 | errno = 0; 18 | if ( (n = pthread_create(&tid, NULL, myfunc, NULL)) != 0) { 19 | printf("pthread_create returned %d, errno = %d\n", n, errno); 20 | 21 | errno = 0; 22 | n = pthread_join(777777, NULL); 23 | printf("pthread_join returned %d, errno = %d\n", n, errno); 24 | 25 | exit(0); 26 | } 27 | printf("created tid %d\n", tid); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /threads/test02.c: -------------------------------------------------------------------------------- 1 | #include "unpthread.h" 2 | 3 | void * 4 | myfunc(void *ptr) 5 | { 6 | int val; 7 | 8 | printf("thread ID of myfunc: %d\n", pthread_self()); 9 | 10 | val = *((int *) ptr); 11 | printf("val = %d\n", val); 12 | sleep(10); 13 | val = *((int *) ptr); 14 | printf("val = %d\n", val); 15 | } 16 | 17 | int 18 | main(int argc, char **argv) 19 | { 20 | pthread_t tid; 21 | int n, val; 22 | 23 | printf("thread ID of main: %d\n", pthread_self()); 24 | 25 | /* Let's verify that the value pointed to the thread's argument is 26 | modifiable */ 27 | val = 123; 28 | if ( (n = pthread_create(&tid, NULL, myfunc, &val)) != 0) 29 | errno = n, err_sys("pthread_create error"); 30 | sleep(5); 31 | val = 789; 32 | sleep(20); 33 | exit(0); 34 | } 35 | -------------------------------------------------------------------------------- /threads/test05.c: -------------------------------------------------------------------------------- 1 | /* See what the implementation returns for TSD keys */ 2 | 3 | #include "unpthread.h" 4 | 5 | pthread_key_t my_key; 6 | 7 | int 8 | main(int argc, char **argv) 9 | { 10 | int *iptr; 11 | 12 | Pthread_key_create(&my_key, NULL); 13 | printf("first key = %d\n", my_key); 14 | 15 | Pthread_key_create(&my_key, NULL); 16 | printf("second key = %d\n", my_key); 17 | 18 | Pthread_key_create(&my_key, NULL); 19 | printf("third key = %d\n", my_key); 20 | 21 | if ( (iptr = pthread_getspecific((pthread_key_t) 0)) == NULL) 22 | printf("key 0 pointer is NULL\n"); 23 | else 24 | printf("value in key 0 = %d\n", *iptr); 25 | 26 | errno = 67; 27 | if ( (iptr = pthread_getspecific((pthread_key_t) 0)) == NULL) 28 | printf("key 0 pointer is NULL\n"); 29 | else 30 | printf("value in key 0 = %d\n", *iptr); 31 | 32 | exit(0); 33 | } 34 | -------------------------------------------------------------------------------- /traceroute/Makefile: -------------------------------------------------------------------------------- 1 | include ../Make.defines 2 | 3 | OBJS = main.o icmpcode_v4.o icmpcode_v6.o recv_v4.o recv_v6.o \ 4 | sig_alrm.o traceloop.o tv_sub.o 5 | PROGS = traceroute 6 | 7 | all: ${PROGS} 8 | 9 | traceroute: ${OBJS} 10 | ${CC} ${CFLAGS} -o $@ ${OBJS} ${LIBS} 11 | 12 | clean: 13 | rm -f ${PROGS} ${CLEANFILES} 14 | -------------------------------------------------------------------------------- /traceroute/icmpcode_v6.c: -------------------------------------------------------------------------------- 1 | #include "trace.h" 2 | 3 | const char * 4 | icmpcode_v6(int code) 5 | { 6 | #ifdef IPV6 7 | static char errbuf[100]; 8 | switch (code) { 9 | case ICMP6_DST_UNREACH_NOROUTE: 10 | return("no route to host"); 11 | case ICMP6_DST_UNREACH_ADMIN: 12 | return("administratively prohibited"); 13 | case ICMP6_DST_UNREACH_NOTNEIGHBOR: 14 | return("not a neighbor"); 15 | case ICMP6_DST_UNREACH_ADDR: 16 | return("address unreachable"); 17 | case ICMP6_DST_UNREACH_NOPORT: 18 | return("port unreachable"); 19 | default: 20 | sprintf(errbuf, "[unknown code %d]", code); 21 | return errbuf; 22 | } 23 | #endif 24 | } 25 | -------------------------------------------------------------------------------- /traceroute/sig_alrm.c: -------------------------------------------------------------------------------- 1 | #include "trace.h" 2 | 3 | int gotalarm; 4 | 5 | void 6 | sig_alrm(int signo) 7 | { 8 | gotalarm = 1; /* set flag to note that alarm occurred */ 9 | return; /* and interrupt the recvfrom() */ 10 | } 11 | -------------------------------------------------------------------------------- /traceroute/tv_sub.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | tv_sub(struct timeval *out, struct timeval *in) 5 | { 6 | if ( (out->tv_usec -= in->tv_usec) < 0) { /* out -= in */ 7 | --out->tv_sec; 8 | out->tv_usec += 1000000; 9 | } 10 | out->tv_sec -= in->tv_sec; 11 | } 12 | -------------------------------------------------------------------------------- /udpcksum/Makefile: -------------------------------------------------------------------------------- 1 | include ../Make.defines 2 | 3 | OBJS = main.o cleanup.o pcap.o udpcksum.o senddnsquery-raw.o udpread.o udpwrite.o 4 | OBJSNET = main.o cleanup.o pcap.o udpcksum.o senddnsquery-libnet.o udpread.o 5 | PROGS = udpcksum udpcksum-libnet 6 | 7 | all: ${PROGS} 8 | 9 | udpcksum: ${OBJS} 10 | ${CC} ${CFLAGS} -o $@ ${OBJS} -L/usr/local/lib -lpcap ${LIBS} 11 | 12 | # Include special linking flags from libnet-config program 13 | udpcksum-libnet: ${OBJSNET} 14 | ${CC} ${CFLAGS} -o $@ ${OBJSNET} -L/usr/local/lib -lpcap ${LIBS} `libnet-config --libs` 15 | 16 | # Include special compilation flags from libnet-config program 17 | senddnsquery-libnet.o: senddnsquery-libnet.c 18 | ${CC} ${CFLAGS} `libnet-config --defines --cflags` -c -o $@ $< 19 | 20 | clean: 21 | rm -f ${PROGS} ${CLEANFILES} 22 | -------------------------------------------------------------------------------- /udpcksum/cleanup.c: -------------------------------------------------------------------------------- 1 | #include "udpcksum.h" 2 | 3 | /* include cleanup */ 4 | void 5 | cleanup(int signo) 6 | { 7 | struct pcap_stat stat; 8 | 9 | putc('\n', stdout); 10 | 11 | if (verbose) { 12 | if (pcap_stats(pd, &stat) < 0) 13 | err_quit("pcap_stats: %s\n", pcap_geterr(pd)); 14 | printf("%d packets received by filter\n", stat.ps_recv); 15 | printf("%d packets dropped by kernel\n", stat.ps_drop); 16 | } 17 | 18 | exit(0); 19 | } 20 | /* end cleanup */ 21 | -------------------------------------------------------------------------------- /udpcliserv/dgcliaddr.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t servlen) 5 | { 6 | int n; 7 | char sendline[MAXLINE], recvline[MAXLINE + 1]; 8 | socklen_t len; 9 | struct sockaddr *preply_addr; 10 | 11 | preply_addr = Malloc(servlen); 12 | 13 | while (Fgets(sendline, MAXLINE, fp) != NULL) { 14 | 15 | Sendto(sockfd, sendline, strlen(sendline), 0, pservaddr, servlen); 16 | 17 | len = servlen; 18 | n = Recvfrom(sockfd, recvline, MAXLINE, 0, preply_addr, &len); 19 | if (len != servlen || memcmp(pservaddr, preply_addr, len) != 0) { 20 | printf("reply from %s (ignored)\n", 21 | Sock_ntop(preply_addr, len)); 22 | continue; 23 | } 24 | 25 | recvline[n] = 0; /* null terminate */ 26 | Fputs(recvline, stdout); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /udpcliserv/dgclibig.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | #undef MAXLINE 4 | #define MAXLINE 65507 5 | 6 | void 7 | dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t servlen) 8 | { 9 | int size; 10 | char sendline[MAXLINE], recvline[MAXLINE + 1]; 11 | ssize_t n; 12 | 13 | size = 70000; 14 | Setsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, &size, sizeof(size)); 15 | Setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, &size, sizeof(size)); 16 | 17 | Sendto(sockfd, sendline, MAXLINE, 0, pservaddr, servlen); 18 | 19 | n = Recvfrom(sockfd, recvline, MAXLINE, 0, NULL, NULL); 20 | 21 | printf("received %d bytes\n", n); 22 | } 23 | -------------------------------------------------------------------------------- /udpcliserv/dgcliconnect.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t servlen) 5 | { 6 | int n; 7 | char sendline[MAXLINE], recvline[MAXLINE + 1]; 8 | 9 | Connect(sockfd, (SA *) pservaddr, servlen); 10 | 11 | while (Fgets(sendline, MAXLINE, fp) != NULL) { 12 | 13 | Write(sockfd, sendline, strlen(sendline)); 14 | 15 | n = Read(sockfd, recvline, MAXLINE); 16 | 17 | recvline[n] = 0; /* null terminate */ 18 | Fputs(recvline, stdout); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /udpcliserv/dgcliinetaddr.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t servlen) 5 | { 6 | int n; 7 | char sendline[MAXLINE], recvline[MAXLINE + 1]; 8 | socklen_t len; 9 | struct sockaddr_in *replyaddr; 10 | 11 | replyaddr = Malloc(servlen); 12 | 13 | while (Fgets(sendline, MAXLINE, fp) != NULL) { 14 | 15 | Sendto(sockfd, sendline, strlen(sendline), 0, pservaddr, servlen); 16 | 17 | len = servlen; 18 | n = Recvfrom(sockfd, recvline, MAXLINE, 0, (SA *) replyaddr, &len); 19 | printf("received reply from %s, port %d\n", 20 | inet_ntoa(replyaddr->sin_addr), htons(replyaddr->sin_port)); 21 | 22 | recvline[n] = 0; /* null terminate */ 23 | Fputs(recvline, stdout); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /udpcliserv/dgcliloop1.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | #define NDG 2000 /* datagrams to send */ 4 | #define DGLEN 1400 /* length of each datagram */ 5 | 6 | void 7 | dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t servlen) 8 | { 9 | int i; 10 | char sendline[DGLEN]; 11 | 12 | for (i = 0; i < NDG; i++) { 13 | Sendto(sockfd, sendline, DGLEN, 0, pservaddr, servlen); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /udpcliserv/dgcliloop3.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | /* Try and get ENOBUFS from sendto() by sending huge datagrams. 4 | But I still cannot get the error. */ 5 | 6 | #define NDG 2000 /* datagrams to send */ 7 | #define DGLEN 65507 /* length of each datagram */ 8 | 9 | void 10 | dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t servlen) 11 | { 12 | int i, n; 13 | char sendline[DGLEN]; 14 | 15 | n = 100 * 1024; 16 | Setsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, &n, sizeof(n)); 17 | 18 | for (i = 0; i < NDG; i++) { 19 | Sendto(sockfd, sendline, DGLEN, 0, pservaddr, servlen); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /udpcliserv/dgecholoop1.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | static void recvfrom_int(int); 4 | static int count; 5 | 6 | void 7 | dg_echo(int sockfd, SA *pcliaddr, socklen_t clilen) 8 | { 9 | socklen_t len; 10 | char mesg[MAXLINE]; 11 | 12 | Signal(SIGINT, recvfrom_int); 13 | 14 | for ( ; ; ) { 15 | len = clilen; 16 | Recvfrom(sockfd, mesg, MAXLINE, 0, pcliaddr, &len); 17 | 18 | count++; 19 | } 20 | } 21 | 22 | static void 23 | recvfrom_int(int signo) 24 | { 25 | printf("\nreceived %d datagrams\n", count); 26 | exit(0); 27 | } 28 | -------------------------------------------------------------------------------- /udpcliserv/dgecholoop2.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | static void recvfrom_int(int); 4 | static int count; 5 | 6 | void 7 | dg_echo(int sockfd, SA *pcliaddr, socklen_t clilen) 8 | { 9 | int n; 10 | socklen_t len; 11 | char mesg[MAXLINE]; 12 | 13 | Signal(SIGINT, recvfrom_int); 14 | 15 | n = 220 * 1024; 16 | Setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, &n, sizeof(n)); 17 | 18 | for ( ; ; ) { 19 | len = clilen; 20 | Recvfrom(sockfd, mesg, MAXLINE, 0, pcliaddr, &len); 21 | 22 | count++; 23 | } 24 | } 25 | 26 | static void 27 | recvfrom_int(int signo) 28 | { 29 | printf("\nreceived %d datagrams\n", count); 30 | exit(0); 31 | } 32 | -------------------------------------------------------------------------------- /udpcliserv/sigchldwaitpid.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | sig_chld(int signo) 5 | { 6 | pid_t pid; 7 | int stat; 8 | 9 | while ( (pid = waitpid(-1, &stat, WNOHANG)) > 0) 10 | printf("child %d terminated\n", pid); 11 | return; 12 | } 13 | -------------------------------------------------------------------------------- /udpcliserv/udpcli01.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: udpcli "); 11 | 12 | bzero(&servaddr, sizeof(servaddr)); 13 | servaddr.sin_family = AF_INET; 14 | servaddr.sin_port = htons(SERV_PORT); 15 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 16 | 17 | sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 18 | 19 | dg_cli(stdin, sockfd, (SA *) &servaddr, sizeof(servaddr)); 20 | 21 | exit(0); 22 | } 23 | -------------------------------------------------------------------------------- /udpcliserv/udpcli02.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: udpcli "); 11 | 12 | bzero(&servaddr, sizeof(servaddr)); 13 | #ifdef HAVE_SOCKADDR_SA_LEN 14 | servaddr.sin_len = sizeof(servaddr); 15 | #endif 16 | servaddr.sin_family = AF_INET; 17 | servaddr.sin_port = htons(7); 18 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 19 | 20 | sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 21 | 22 | dg_cli(stdin, sockfd, (SA *) &servaddr, sizeof(servaddr)); 23 | 24 | exit(0); 25 | } 26 | -------------------------------------------------------------------------------- /udpcliserv/udpcli03.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: udpcli "); 11 | 12 | bzero(&servaddr, sizeof(servaddr)); 13 | servaddr.sin_family = AF_INET; 14 | servaddr.sin_port = htons(7); 15 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 16 | 17 | sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 18 | 19 | dg_cli(stdin, sockfd, (SA *) &servaddr, sizeof(servaddr)); 20 | 21 | exit(0); 22 | } 23 | -------------------------------------------------------------------------------- /udpcliserv/udpcli04.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: udpcli "); 11 | 12 | bzero(&servaddr, sizeof(servaddr)); 13 | servaddr.sin_family = AF_INET; 14 | servaddr.sin_port = htons(SERV_PORT); 15 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 16 | 17 | sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 18 | 19 | dg_cli(stdin, sockfd, (SA *) &servaddr, sizeof(servaddr)); 20 | 21 | exit(0); 22 | } 23 | -------------------------------------------------------------------------------- /udpcliserv/udpcli05.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: udpcli "); 11 | 12 | bzero(&servaddr, sizeof(servaddr)); 13 | servaddr.sin_family = AF_INET; 14 | servaddr.sin_port = htons(SERV_PORT); 15 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 16 | 17 | sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 18 | 19 | bzero(&cliaddr, sizeof(cliaddr)); 20 | cliaddr.sin_family = AF_INET; 21 | cliaddr.sin_addr.s_addr = htonl(INADDR_ANY); 22 | cliaddr.sin_port = htons(0); /* force assignment of ephemeral port */ 23 | Bind(sockfd, (SA *) &cliaddr, sizeof(cliaddr)); 24 | 25 | dg_cli(stdin, sockfd, (SA *) &servaddr, sizeof(servaddr)); 26 | 27 | exit(0); 28 | } 29 | -------------------------------------------------------------------------------- /udpcliserv/udpcli06.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: udpcli "); 11 | 12 | bzero(&servaddr, sizeof(servaddr)); 13 | servaddr.sin_family = AF_INET; 14 | servaddr.sin_port = htons(SERV_PORT); 15 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 16 | 17 | sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 18 | 19 | dg_cli(stdin, sockfd, (SA *) &servaddr, sizeof(servaddr)); 20 | 21 | exit(0); 22 | } 23 | -------------------------------------------------------------------------------- /udpcliserv/udpcli08.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr; 8 | 9 | if (argc != 2) 10 | err_quit("usage: udpcli "); 11 | 12 | bzero(&servaddr, sizeof(servaddr)); 13 | servaddr.sin_family = AF_INET; 14 | servaddr.sin_port = htons(9); /* discard server */ 15 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 16 | 17 | sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 18 | 19 | dg_cli(stdin, sockfd, (SA *) &servaddr, sizeof(servaddr)); 20 | 21 | exit(0); 22 | } 23 | -------------------------------------------------------------------------------- /udpcliserv/udpcli09.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | socklen_t len; 8 | struct sockaddr_in cliaddr, servaddr; 9 | 10 | if (argc != 2) 11 | err_quit("usage: udpcli "); 12 | 13 | sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 14 | 15 | bzero(&servaddr, sizeof(servaddr)); 16 | servaddr.sin_family = AF_INET; 17 | servaddr.sin_port = htons(SERV_PORT); 18 | Inet_pton(AF_INET, argv[1], &servaddr.sin_addr); 19 | 20 | Connect(sockfd, (SA *) &servaddr, sizeof(servaddr)); 21 | 22 | len = sizeof(cliaddr); 23 | Getsockname(sockfd, (SA *) &cliaddr, &len); 24 | printf("local address %s\n", Sock_ntop((SA *) &cliaddr, len)); 25 | 26 | exit(0); 27 | } 28 | -------------------------------------------------------------------------------- /udpcliserv/udpcli10.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | socklen_t salen; 8 | struct sockaddr *sa; 9 | 10 | if (argc != 3) 11 | err_quit("usage: udpcli02 "); 12 | 13 | sockfd = Udp_client(argv[1], argv[2], (void **) &sa, &salen); 14 | 15 | dg_cli(stdin, sockfd, sa, salen); 16 | 17 | exit(0); 18 | } 19 | -------------------------------------------------------------------------------- /udpcliserv/udpserv01.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr, cliaddr; 8 | 9 | sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 10 | 11 | bzero(&servaddr, sizeof(servaddr)); 12 | servaddr.sin_family = AF_INET; 13 | servaddr.sin_addr.s_addr = htonl(INADDR_ANY); 14 | servaddr.sin_port = htons(SERV_PORT); 15 | 16 | Bind(sockfd, (SA *) &servaddr, sizeof(servaddr)); 17 | 18 | dg_echo(sockfd, (SA *) &cliaddr, sizeof(cliaddr)); 19 | } 20 | -------------------------------------------------------------------------------- /udpcliserv/udpserv06.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr, cliaddr; 8 | 9 | sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 10 | 11 | bzero(&servaddr, sizeof(servaddr)); 12 | servaddr.sin_family = AF_INET; 13 | servaddr.sin_addr.s_addr = htonl(INADDR_ANY); 14 | servaddr.sin_port = htons(SERV_PORT); 15 | 16 | Bind(sockfd, (SA *) &servaddr, sizeof(servaddr)); 17 | 18 | dg_echo(sockfd, (SA *) &cliaddr, sizeof(cliaddr)); 19 | } 20 | -------------------------------------------------------------------------------- /udpcliserv/udpserv07.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_in servaddr, cliaddr; 8 | 9 | sockfd = Socket(AF_INET, SOCK_DGRAM, 0); 10 | 11 | bzero(&servaddr, sizeof(servaddr)); 12 | servaddr.sin_family = AF_INET; 13 | servaddr.sin_addr.s_addr = htonl(INADDR_ANY); 14 | servaddr.sin_port = htons(SERV_PORT); 15 | 16 | Bind(sockfd, (SA *) &servaddr, sizeof(servaddr)); 17 | 18 | dg_echo(sockfd, (SA *) &cliaddr, sizeof(cliaddr)); 19 | } 20 | -------------------------------------------------------------------------------- /unixdomain/daytimetcpcli.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd, n; 7 | char recvline[MAXLINE + 1]; 8 | socklen_t len; 9 | struct sockaddr *sa; 10 | 11 | if (argc != 3) 12 | err_quit("usage: daytimetcpcli "); 13 | 14 | sockfd = Tcp_connect(argv[1], argv[2]); 15 | 16 | sa = Malloc(sizeof(struct sockaddr_storage)); 17 | len = sizeof(struct sockaddr_storage); 18 | Getpeername(sockfd, sa, &len); 19 | printf("connected to %s\n", Sock_ntop_host(sa, len)); 20 | sleep(5); 21 | 22 | while ( (n = Read(sockfd, recvline, MAXLINE)) > 0) { 23 | recvline[n] = 0; /* null terminate */ 24 | printf("%d bytes: %s", n, recvline); 25 | } 26 | exit(0); 27 | } 28 | -------------------------------------------------------------------------------- /unixdomain/daytimetcpsrv2.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | #include 3 | 4 | int 5 | main(int argc, char **argv) 6 | { 7 | int i, listenfd, connfd; 8 | socklen_t addrlen, len; 9 | struct sockaddr *cliaddr; 10 | char buff[MAXLINE]; 11 | time_t ticks; 12 | 13 | if (argc == 2) 14 | listenfd = Tcp_listen(NULL, argv[1], &addrlen); 15 | else if (argc == 3) 16 | listenfd = Tcp_listen(argv[1], argv[2], &addrlen); 17 | else 18 | err_quit("usage: daytimetcpsrv2 [ ] "); 19 | 20 | cliaddr = Malloc(addrlen); 21 | 22 | for ( ; ; ) { 23 | len = addrlen; 24 | connfd = Accept(listenfd, cliaddr, &len); 25 | printf("connection from %s\n", Sock_ntop(cliaddr, len)); 26 | 27 | ticks = time(NULL); 28 | snprintf(buff, sizeof(buff), "%.24s\r\n", ctime(&ticks)); 29 | for (i = 0; i < strlen(buff); i++) 30 | Send(connfd, &buff[i], 1, MSG_EOR); 31 | 32 | Close(connfd); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /unixdomain/mycat.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int my_open(const char *, int); 4 | 5 | int 6 | main(int argc, char **argv) 7 | { 8 | int fd, n; 9 | char buff[BUFFSIZE]; 10 | 11 | if (argc != 2) 12 | err_quit("usage: mycat "); 13 | 14 | if ( (fd = my_open(argv[1], O_RDONLY)) < 0) 15 | err_sys("cannot open %s", argv[1]); 16 | 17 | while ( (n = Read(fd, buff, BUFFSIZE)) > 0) 18 | Write(STDOUT_FILENO, buff, n); 19 | 20 | exit(0); 21 | } 22 | -------------------------------------------------------------------------------- /unixdomain/openfile.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int fd; 7 | 8 | if (argc != 4) 9 | err_quit("openfile "); 10 | 11 | if ( (fd = open(argv[2], atoi(argv[3]))) < 0) 12 | exit( (errno > 0) ? errno : 255 ); 13 | 14 | if (write_fd(atoi(argv[1]), "", 1, fd) < 0) 15 | exit( (errno > 0) ? errno : 255 ); 16 | 17 | exit(0); 18 | } 19 | -------------------------------------------------------------------------------- /unixdomain/sigchldwaitpid.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | void 4 | sig_chld(int signo) 5 | { 6 | pid_t pid; 7 | int stat; 8 | 9 | while ( (pid = waitpid(-1, &stat, WNOHANG)) > 0) { 10 | printf("child %d terminated\n", pid); 11 | } 12 | return; 13 | } 14 | -------------------------------------------------------------------------------- /unixdomain/testfcred.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | #include 3 | #include 4 | 5 | main() 6 | { 7 | printf("sizeof(struct fcred) = %d\n", sizeof(struct fcred)); 8 | printf("sizeof(struct cmsghdr) = %d\n", sizeof(struct cmsghdr)); 9 | exit(0); 10 | } 11 | -------------------------------------------------------------------------------- /unixdomain/unixbind.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | socklen_t len; 8 | struct sockaddr_un addr1, addr2; 9 | 10 | if (argc != 2) 11 | err_quit("usage: unixbind "); 12 | 13 | sockfd = Socket(AF_LOCAL, SOCK_STREAM, 0); 14 | 15 | unlink(argv[1]); /* OK if this fails */ 16 | 17 | bzero(&addr1, sizeof(addr1)); 18 | addr1.sun_family = AF_LOCAL; 19 | strncpy(addr1.sun_path, argv[1], sizeof(addr1.sun_path)-1); 20 | Bind(sockfd, (SA *) &addr1, SUN_LEN(&addr1)); 21 | 22 | len = sizeof(addr2); 23 | Getsockname(sockfd, (SA *) &addr2, &len); 24 | printf("bound name = %s, returned len = %d\n", addr2.sun_path, len); 25 | 26 | exit(0); 27 | } 28 | -------------------------------------------------------------------------------- /unixdomain/unixdgcli01.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_un cliaddr, servaddr; 8 | 9 | sockfd = Socket(AF_LOCAL, SOCK_DGRAM, 0); 10 | 11 | bzero(&cliaddr, sizeof(cliaddr)); /* bind an address for us */ 12 | cliaddr.sun_family = AF_LOCAL; 13 | strcpy(cliaddr.sun_path, tmpnam(NULL)); 14 | 15 | Bind(sockfd, (SA *) &cliaddr, sizeof(cliaddr)); 16 | 17 | bzero(&servaddr, sizeof(servaddr)); /* fill in server's address */ 18 | servaddr.sun_family = AF_LOCAL; 19 | strcpy(servaddr.sun_path, UNIXDG_PATH); 20 | 21 | dg_cli(stdin, sockfd, (SA *) &servaddr, sizeof(servaddr)); 22 | 23 | exit(0); 24 | } 25 | -------------------------------------------------------------------------------- /unixdomain/unixdgserv01.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_un servaddr, cliaddr; 8 | 9 | sockfd = Socket(AF_LOCAL, SOCK_DGRAM, 0); 10 | 11 | unlink(UNIXDG_PATH); 12 | bzero(&servaddr, sizeof(servaddr)); 13 | servaddr.sun_family = AF_LOCAL; 14 | strcpy(servaddr.sun_path, UNIXDG_PATH); 15 | 16 | Bind(sockfd, (SA *) &servaddr, sizeof(servaddr)); 17 | 18 | dg_echo(sockfd, (SA *) &cliaddr, sizeof(cliaddr)); 19 | } 20 | -------------------------------------------------------------------------------- /unixdomain/unixstrcli01.c: -------------------------------------------------------------------------------- 1 | #include "unp.h" 2 | 3 | int 4 | main(int argc, char **argv) 5 | { 6 | int sockfd; 7 | struct sockaddr_un servaddr; 8 | 9 | sockfd = Socket(AF_LOCAL, SOCK_STREAM, 0); 10 | 11 | bzero(&servaddr, sizeof(servaddr)); 12 | servaddr.sun_family = AF_LOCAL; 13 | strcpy(servaddr.sun_path, UNIXSTR_PATH); 14 | 15 | Connect(sockfd, (SA *) &servaddr, sizeof(servaddr)); 16 | 17 | str_cli(stdin, sockfd); /* do it all */ 18 | 19 | exit(0); 20 | } 21 | --------------------------------------------------------------------------------