Beej útmutatója a hálózati programozáshoz

3. structok és adatkezelés

Nos, végül ide értünk. Itt az ideje beszélni a programozásról. Ebben a fejezetben megtárgyaljuk az adattípusok különböző fajtáinak használatát socket interfésszel, párat közülük kicsit jobban is szemügyre veszünk.

Először egy egyszerűt: egy socket leíró. A socket leíró a következő típus:

int

struct sockaddr {

unsigned short sa_family; // címcsalád, AF_xxx
char sa_data[14]; // a protocol cím 14 bájtja

};

struct sockaddr_in {

short int sin_family; // cím család
unsigned short int sin_port; // port szám
struct in_addr sin_addr; // internet cím
unsigned char sin_zero[8]; // ugyanakkora méretben, mint a struct sockaddr-ben

};

// Internet address (cím) (egy struktúra kiemelkedő okokkal)
struct in_addr {

unsigned long s_addr; // ez egy 32 bites long, vagy 4 bájt
};

3.1. Convert the Natives!

Egy újabb fejezetbe vezettek minket. Már így is sokat beszéltünk erről a hálózat - Host Byte Order konverzióról - itt az ideje, hogy csináljunk is végre valamit!

Rendben. Két típus van, amit konvertálhatsz: short (2 bájt) és long (4 bájt). Ezek a függvények az unsigned variációkkal szintén működnek. Azt mondod, hogy egy short típust szeretnél Host Byte Orderről Network Byte Orderbe konvertálni. Kezd "h"-val a "host" miatt, ezt kövesse "to", aztán "n" a "network" miatt, aztán "s" a "short" miatt: h-to-n-s, vagy htons() (olvasd: "Host to Network Short").

Ez majdnem hogy túl könnyű...

Az összes kombinációt használhatod, akár "n","h","s" és "l" az amit szertnél, nem számolva a hülyeségeket. Például NINCS stolh() ("Short to Long Host") függvény. De a következők léteznek:

3.2. IP cím, Hogyan foglalozzunk velük?

Szerencsédre egy csokor függvény létezik, amelyek könnyű kezelhetőséget adnak az IP címekhez. Nincs szükség kézzel való beállítgatásokra, és berakni egy long-ba az << operátorral.

Először mondjuk, hogy van egy ina nevű sockaddr_in struktúrád, és van egy "10.12.110.57"-es IP címed, amelyet el szeretnél benne tárolni. A függvény, amit használni szeretnél, inet_addr(), egy IP címet számok-és-pontok jelölésrendszert konvertál egy unsigned long típusba. A feladatot a következő módon oldhatjuk meg:

ina.sin_addr.s_addr = inet_addr("10.12.110.57");

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

int inet_aton(const char *cp, struct in_addr *inp);

struct sockaddr_in my_addr;

my_addr.sin_family = AF_INET; // host byte order
my_addr.sin_port = htons(MYPORT); // short, network byte order
inet_aton("10.12.110.57", &(my_addr.sin_addr));
memset(&(my_addr.sin_zero), '\0', 8); // nulla a strutúra maradék részében

printf("%s", inet_ntoa(ina.sin_addr));

char *a1, *a2;
.
.
a1 = inet_ntoa(ina1.sin_addr); // ez a 192.168.4.14
a2 = inet_ntoa(ina2.sin_addr); // ez a 10.12.110.57
printf("address 1: %s\n",a1);
printf("address 2: %s\n",a2);

address 1: 10.12.110.57
address 2: 10.12.110.57

4. Rendszer hívások vagy fagyások

Ebben a fejezetben a rendszerhívásokat fogjuk tárgyalni. Azokat, amelyek hozzáférést engednek egy Unixos doboz hálózati függvényihez. Amikor te meghívsz egyet ezek a függvények közül, akkor a kernel veszi kezelésbe a dolgokat, és mindent elintéz neked autómatikusan. Hát nem csodálatos?

A hely, ahol a legtöbb ember elakad, hogy milyen sorrendben hívja meg ezeket a dolgokat. Ebben az esetben a man oldalak sem segítenek, ahogy már biztosan te is felfedezted. Nos, hogy segíthessek ezen a rettenetes helyzeten, megpróbáltam felsorakoztatni a rendszerhívásokat a következő fejezetekben pontosan (körülbelül) abban a sorrendben, ahogy neked a programodban meg kell majd hívnod őket.

Ezeket itt-ott kisebb kóddarabkákkal párosítottam, egy kis tej és süti (amelyeket félek, hogy fel is használsz majd öncélúan), és pár nyers bél és bátorság, és aztán úgy fogod az adatokat sugározni az Interneten mint Csernobil 86-ban!

4.1. socket() - Vegyük a fájlleírót!

Szerintem nem kell túl hosszú időt rászánnom - a socket() függvényről kell beszélnem. Itt az elemzés:

#incldue <sys/types.h>
#include <sys/socket.h>

int socket(int domain, int type, int protocol);

4.2. bind() - Milyen porton vagyok?

Mikor van egy socketed, akkor társítanod kell a helyi géped egy portjához. (Ez rendszerint elvégződik, amikor bejövő csatlakozásokhoz listen() (hallgatsz) kifele egy meghatározott porton - MUDok teszik ezt meg mikor megkérnek, hogy "telnetelj az x.y.z-re a 6969-es porton" (telnet to x.y.z port 6969).) A portszámot a kernel használja, hogy összekapcsoljon egy bejövő csomagot egy meghatározott process socket leírójával. Ha csak egy connect() (kapcsolatot) akarsz létrehozni, akkor nem szükséges. Minden esetre olvasd el, csak úgy heccből.

Itt van a bind() rendszerhívás vázlata:

#include <sys/types.h>
#include <sys/socket.h>

int bind(int sockfd, struct sockaddr *my_addr, int addrlen);

#include <string.h>
#include <sys/types.h>
#incldue <sys/socket.h>
#include <netinet/in.h>

#define MYPORT 3490

main()
{

int sockfd;
struct sockaddr_in my_addr;
sockfd = socket(AF_INET, SOCK_STREAM, 0); // csináld meg a hibavizsgálatot!

my_addr.sin_family = AF_INET; // host byte order
my_addr.sin_port = htons(MYPORT); // short, network byte order
my_addr.sin_addr.s_addr = inet_addr("10,12,110,57");
memset(&(my_addr.sin_zero), '\0', 8); // a struktúra többi részét kinullázza

// el ne felejtsd megcsinálni a hiba vizsgálatot a bind()-nek:
bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr));
.
.
.

my_addr.sin_port = 0; // válassz egy szabad portot véletlenszerűen
my_addr.sin_addr.s_addr = INADDR_ANY; // haszáld az én IP címemet

my_addr.sin_port = htons(0); // válassz egy használaton kívüli portot véletlenszerűen
my_addr.sin_addr.s_addr = htonl(INADDR_ANY); // használd az én IP címem

int yes=1;

// az idegekre menő "Address already in use" hiba üzenet
if (setsockopt(listener,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)) == -1) {

perror("setsockopt");
exit(1);
}

4.3. connect() - Hey, te!

Most csináljunk úgy egy pár percig, mintha te egy telnet alkalmazás lennél. A te felhasználód azt parancsolja, hogy vegyed a socket fájlleírót. Te teljesíted és meghívod a socket() függvényt. Következőben a felhasználó azt mondja, hogy csatlakozz a "10.12.110.57"-es címre a "23"-as porton keresztül (a szabványos telnet port.) Hoppá! Most mit csinálsz?

Szerencséd van, program, olvasd át figyelmesen a connect() függvényről szóló részt - hogyan csatlakozzunk egy távoli hosthoz. Olvasd át őrült vágtában. Ne vesztegess több időt!

A connect() hívás olyan mint a következő:

#include <sys/types.h>
#include <sys/socket.h>

int connect(int sockfd, struct sockaddr *serv_addr, int addrlen);

#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define DEST_IP "10.12.110.57"
#define DEST_PORT 23

main()
{

int sockfd;
struct sockaddr_in dest_addr; // ez fogja tárolni a cél címét

sockfd = socket(AF_INET, SOCK_STREAM, 0); // csináld meg a hibavizsgálatát!

dest_addr.sin_family = AF_INET; // host byte order
dest_addr.sin_port = htons(DEST_PORT); // short, network byte order
dest_addr.sin_addr.s_addr = inet_addr(DEST_IP);
memset(&(dest_addr.sin_zero),'\0',8); // a struktúra többi részének kinullázása

//ne felejtsd el megcsinálni a hibavizsgálatot
connect(sockfd, (struct sockaddr *)&dest_addr, sizeof(struct sockaddr));
.
.
.

4.4. listen() - Felhívna valaki?

Ok, itt az ideje az irányváltásra. Mi van akkor, ha nem akarsz csatlakozni egy távoli hosthoz. Mondjuk, csak úgy heccből, bejövő csatlakozásokra akarsz várni, és kezelni szeretnéd őket különböző utakon. A folyamat két lépésből áll: először te listen() (hallgatsz), aztán accept() (elfogadod) (lásd alább.)

A listen hívás egyszerűen világos, bár egy kis magyarázatot igényel:

int listen(int sockfd, int backlog);

socket();
bind();
listen();
/* accept() ide jön */

4.5. accept() - "Köszi, hogy hívtál 3490-es port."

Kösd fel a gatyád, mert az accept() egy undorító fajta! Mi történik akkor, ha valaki nagyon-nagyon messziről próbál csatlakozni egy olyan portodra amire neked egy listen() függvényed figyel. A csatlakzozási kérvények sorba állnak és várakoznak, hogy az accept() függvénnyel elfogadd őket. Meghívod az accept() függvényt és megmondod neki, hogy vegye a feltételezett kapcsolatot. Ez egy vadi új socket fájlleíróval fog visszatérni, hogy egy egyedüli csatlakozáshoz használja! Ez így rendben is van, hirtelen két socket fájlleíród van egyért cserében! Az eredeti még mindig az adott portodat figyeli, az újabban létrehozott pedig készen áll hogy send() (küldjön) és recv() (fogadjon). Végre elérkeztünk ide is!

A hívás a következő képpen néz ki:

#include <sys/socket.h>

int accept(int sockfd, void *addr, int *addrlen);

#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define MYPORT 3490 // a port ahova a felhasználók csatlakozni fognak

#define BACKLOG 10 // mennyi elintézetlen kapcsolatot enged sorban állni

main()
{

int sockfd, new_fd; // listen a sock_fd-n, új kapcsolat a new_fd-n
struct sockaddr_in my_addr; // az én címinformációm
struct sockaddr_in their_addr; // a csatlakozó fél címinformációja
int sin_size;

sockfd = socket(AF_INET, SOCK_STREAM, 0); // a hiba figyelése a te dolgod!

my_addr.sin_family = AF_INET; // host byte order
my_addr.sin_port = htons(MYPORT); // short, network byte order
my_addr.sin_addr.s_addr = INADDR_ANY; // automatikusan kitölti az én IP-mel
memset(&(my_addr.sin_zero), ’\0’, 8); // kinullázza struktúra többi részét

// El ne felejtsd megcsinálni a hibavizsgálatát ezeknek a hívásoknak:
bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr));

listen(sockfd, BACKLOG);

sin_size = sizeof(struct sockaddr_in);
new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size);
.
.
.

4.6. send() és recv() - Szólj hozzám bébi!

Ez a két függvény a stream socketen vagy kapcsolt datagram socketen keresztüli kommunikációra szolgál. Abban az esetben, ha kapcsolat nélküli datagram socketet akarsz használni, akkor szükséges lesz elolvasnod a sendto() és recvfrom() függvényekről szóló fejezetet, lentebb.

A send() hívás:

int send(int sockfd, const void *msg, int len, int flags);

char *msg = "Beej was here!";
int len, bytes_sent;
.
.
len = strlen(msg);
bytes_sent = send(sockfd, msg, len, 0);
.
.
.

int recv(int sockfd, void *buf, int len, unsigned int flags);

4.7. sendto() és recvfrom() - Beszélj hozzám, DGRAM-stílus

"Ez mind szép és remek," - hallom, ahogy mondod, - "de mire megyek ezzel a kapcsolatnélküli datagram socketeknél?"
Semmi gond amigo. Meg van a megoldás.

Mivel a datagram socketek nem csatlakoznak egy távoli hosthoz, tippelj, melyik darab információra lesz szükségünk, mielőtt elküldjük a csomagot? Így van! A cél címére! Itt a megoldás:

int sendto(int sockfd, const void *msg, int len, unsigned int flags, const struct sockaddr *to, int tolen);

int recvfrom(int sockfd, void *buf, int len, unsigned int flags, struct sockaddr *from, int *fromlen);

4.8. close() és shutdown() - Viszlát!

Húha! Egész nap adatokat küldtél és fogadtál (send()/recv()) és mindent elintéztél. Készen állsz, hogy befejezd a kapcsolatot a socket leírodban. Ez elég könnyű. Máris használhatod a Unix szokásos fájlleírójának a close() függvényét:

close(sockfd);

int shutdown(int sockfd, int how);

4.9. getpeername() - Ki vagy?

Ez a függvény nagyon egyszerű.

Annyira könnyű, hogy majdnem nem is adtam neki külön fejezetet. No de azért mégis itt van.

A getpeername() függvény megmondja, hogy ki van a stream socket kapcsolat túloldalán. A használata:

#include <sys/socket.h>

int getpeername(int sockfd, struct sockaddr *addr, int *addrlen);

4.10. gethostname() - Ki vagyok?

A getpeername() függvénynél már csak a gethostname() egyszerűbb. Annak a számítógépnek a nevével tér vissza, amelyiken a programot futtatod. Ez a név használható ezek után a gethostbyname() (lásd lejjebb) függvény paramétereként, hogy visszakapd a helyi számítógéped IP címét.

Mi tudna még több örömöt okozni? Hát mondjuk, most eszembe jutott egy-kettő, de azok nem kapcsolódnak a socket programozáshoz. Minden esetre, a lényeg a következő:

#include <unistd.h>

int gethostname(char *hostname, size_t size);

4.11. DNS

(Amire te azt mondod "whitehouse.gov", én azt mondom "198.137.240.92")

Abban az esetben, ha nem tudnád, hogy mi is az a DNS, nos a "Domain Name Service"-t takarja. Dióhélyban annyi, hogy te megadod az emberileg olvasható címét a sitenak, ő pedig az IP címét fogja neked adni (így használhatod a bind(), connect(), sendto(), stb. függvényekkel, arra amire csak akarod.) Ezúton, ha valaki a következőt írja be:

$ telnet whitehouse.gov

#include <netdb.h>

struct hostent *gethostbyname(const char *name);

struct hostent {

char *h_name; char **h_aliases; int h_addrtype; int h_length; char **h_addr_list;
};
#define h_addr h_addr_list[0]

/*
** getip.c - egy hostnév kereső demo
*/

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

int main(int argc, char *argv[])
{

struct hostent *h;

if (argc != 2) { // a parancssor hibavizsgálata

fprintf(stderr,"usage: getip address\n");
exit(1);
}

if ((h=gethostbyname(argv[1])) == NULL) { // a host információt megkapja

herror("gethostbyname");
exit(1);
}

printf("Host name : %s\n", h->h_name);
printf("IP Address : %s\n", inet_ntoa(*((struct in_addr *)h->h_addr)));

return 0;
}

2. ábra - Kliens-Szerver kölcsönhatás:

5. Kliens-Szerver háttér

Ez egy kliens-szerver világ öcsi! A hálózati életben szinte minden esetben kliens folyamatok szerver folyamatoknak beszélnek, és fordítva. Vegyük a telnet-et példaként. Amikor te a 23-as porton egy távoli hostra telnetelsz (kliens), egy azon a hoston lévő program (hívd telnetd-nek, a szerver) fakad életre. Ez kezeli a bejövő telnet csatlakozásokat, egy login(bejelentkező) promptot rak ki neked, stb.

Az információcsere a kliens és a szerver között a 2. ábrán látható.

Megjegyezzük, hogy a kliens-szerver pár SOCK_STREAM, SOCK_DGRAM, vagy bármi máson tud egymással beszélni (egész addig, amíg hasonló dolgokról beszélnek.) Pár jó példa a kliens-szerver párokra a telnet/telnetd, ftp/ftpd, vagy a bootp/bootpd. Akárhányszor ftp-t használsz, a távoli program az ftpd lesz, ami kiszolgál téged.

Gyakran csak egy szerver program van egy gépen és ez összetetten kezeli a különböző klienseket a fork() használatával. Az alap eljárás a következő: a szerver egy kapcsolatra vár, accept() azaz elfogadja azt, aztán az elágaztatásra a fork() függvényt használja, ami segítsgével egy gyerek folyamat fogja kezelni a kapcsolatot. Ez az, amit a mi minta szerverünk is tesz a következő részben.

5.1. Egy egyszerű Stream szerver

Az össz dolog, amit ez a szerver csinál, az az, hogy kiír egy "Hello, World!\n" stringet egy stream kapcsolaton keresztül. Az össz dolgod, amit a tesztelés érdekében tenned kell, hogy elindítod ezt a szervert egy ablakban, egy másikban pedig rátelnetezel:

$ telnet remotehostname 3490

/*
** server.c - egy stream socket szerver demo
*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <signal.h>

#define MYPORT 3490 // a port használói ide fognak csatlakozni

#define BACKLOG 10 // mennyi kezeletlen kapcsolat várakozhat sorban

void sigchld_handler(int s)
{

while(wait(NULL) > 0);
}

int main(void)
{

int sockfd, new_fd; // figyelés-hallgatás a sock_fd-n, új kapcsolat a new_fd-n
struct sockaddr_in my_addr; // a saját címinformációm
struct sockaddr_in their_addr; // a csatlakozó címinformációja
int sin_size;
struct sigaction sa;
int yes=1;

if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {

perror("socket");
exit(1);
}

if (setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)) == -1) {

perror("setsockopt");
exit(1);
}

my_addr.sin_family = AF_INET; // host byte order
my_addr.sin_port = htons(MYPORT); // short, network byte order
my_addr.sin_addr.s_addr = INADDR_ANY; // automatikusan kitölti az IP-mel
memset(&(my_addr.sin_zero), ’\0’, 8); // nulla a struktúra többi részében

if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1) {

perror("bind");
exit(1);
}

if (listen(sockfd, BACKLOG) == -1) {

perror("listen");
exit(1);
}

sa.sa_handler = sigchld_handler; // levág minden halott folyamatot
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART;
if (sigaction(SIGCHLD, &sa, NULL) == -1) {

perror("sigaction");
exit(1);
}

while(1) { // main accept() loop

sin_size = sizeof(struct sockaddr_in);
if ((new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size)) == -1) {

perror("accept");
continue;
}
printf("server: got connection from %s\n",inet_ntoa(their_addr.sin_addr));
if (!fork()) { // ez a gyerek folyamat

close(sockfd); // a gyereknek nincs szüksége a listázóra
if (send(new_fd, "Hello, world!\n", 14, 0) == -1)

perror("send");
close(new_fd);
exit(0);
}
close(new_fd); // a szülőnek nincs szüksége erre
}

return 0;
}

5.2. Egy egyszerű Stream kliens

Ez a srác sokkal könnyebb eset, mint a szerver haverja. Annyit csinál összesen, hogy kapcsolódik a parancssorban megadott 3490-es portszámon keresztül. Aztán megkapja a sztringet, amit a szerver küldött.

A kliens forráskódja¹³:

/*
** client.c - egy stream socket kliens demo
*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>

#define PORT 3490 // az a port, ahova a kliens csatlakozni fog

#define MAXDATASIZE 100 // az egyszerre kapható bájtok maximális értéke

int main(int argc, char *argv[])
{

int sockfd, numbytes;
char buf[MAXDATASIZE];
struct hostent *he;
struct sockaddr_in their_addr; // a csatlakozó címinformációja

if (argc != 2) {

fprintf(stderr,"usage: client hostname\n");
exit(1);
}

if ((he=gethostbyname(argv[1])) == NULL) { // megkapja a hostinformációt

perror("gethostbyname");
exit(1);
}

if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {

perror("socket");
exit(1);
}

their_addr.sin_family = AF_INET; // host byte order
their_addr.sin_port = htons(PORT); // short, network byte order
their_addr.sin_addr = *((struct in_addr *)he->h_addr);
memset(&(their_addr.sin_zero), ’\0’, 8); // kinullázza a struktúra többi részét

if (connect(sockfd, (struct sockaddr *)&their_addr,sizeof(struct sockaddr)) == -1) {

perror("connect");
exit(1);
}

if ((numbytes=recv(sockfd, buf, MAXDATASIZE-1, 0)) == -1) {

perror("recv");
exit(1);
}

buf[numbytes] = ’\0’;

printf("Received: %s",buf);

close(sockfd);

return 0;
}

5.3. Datagram socketek

Én tényleg nem szeretnék sokat beszélni itt, így bemutatok egy pár minta programot: talker.c és listener.c.

A listner egy gépen ül és bejövő csomagokra vár a 4950-es porton. A talker egy csomagot küld ugyanarra a portra,a meghatározott gépen, a csomag bármit tartalmazhat, amit a felhasználó beír a parancssorba.

Jöjjön a listner.c¹⁴ forráskódja:

/*
** listener.c - egy datagram sockets "szerver" demo
*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define MYPORT 4950 // az a port ahova a felhasználó kapcsolódni fog

#define MAXBUFLEN 100

int main(void)
{

int sockfd;
struct sockaddr_in my_addr; // my address information
struct sockaddr_in their_addr; // connector's address information
int addr_len, numbytes;
char buf[MAXBUFLEN];

if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {

perror("socket");
exit(1);
}

my_addr.sin_family = AF_INET; // host byte order
my_addr.sin_port = htons(MYPORT); // short, network byte order
my_addr.sin_addr.s_addr = INADDR_ANY; // automatikusan kitöltődik a saját IP-mel
memset(&(my_addr.sin_zero), ’\0’, 8); // kinullázza a struktúra többi részét

if (bind(sockfd, (struct sockaddr *)&my_addr,sizeof(struct sockaddr)) == -1) {

perror("bind");
exit(1);
}

addr_len = sizeof(struct sockaddr);
if ((numbytes=recvfrom(sockfd,buf, MAXBUFLEN-1, 0,(struct sockaddr *)&their_addr, &addr_len)) == -1) {

perror("recvfrom");
exit(1);
}

printf("got packet from %s\n",inet_ntoa(their_addr.sin_addr));
printf("packet is %d bytes long\n",numbytes);
buf[numbytes] = ’\0’;
printf("packet contains \"%s\"\n",buf);

close(sockfd);

return 0;
}

/*
** talker.c - egy datagram "kliens" demo
*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>

#define MYPORT 4950 // a port, ahova a felhasználók csatlakozni fognak

int main(int argc, char *argv[])
{

int sockfd;
struct sockaddr_in their_addr; // a csatlakozó címinformációja
struct hostent *he;
int numbytes;

if (argc != 3) {

fprintf(stderr,"usage: talker hostname message\n");
exit(1);
}

if ((he=gethostbyname(argv[1])) == NULL) { // veszi a hosztinformációt
perror("gethostbyname");
exit(1);
}

if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {

perror("socket");
exit(1);
}

their_addr.sin_family = AF_INET; // host byte order
their_addr.sin_port = htons(MYPORT); // short, network byte order
their_addr.sin_addr = *((struct in_addr *)he->h_addr);
memset(&(their_addr.sin_zero), ’\0’, 8); // kinullázza a struktúra maradék részét

if ((numbytes=sendto(sockfd, argv[2], strlen(argv[2]), 0,(struct sockaddr *)&their_addr, sizeof(struct sockaddr))) == -1) {

perror("sendto");
exit(1);
}

printf("sent %d bytes to %s\n", numbytes,inet_ntoa(their_addr.sin_addr));

close(sockfd);

return 0;

6. Kicsit fejlettebb teknikák

Ezek nem is igazán fejlettebbek, de mégis kivezetnek bennünket a legtöbb alapabb szintből, amiket már lefektettünk. Abban az esetben, ha ilyen távolra jutottál, fel kell ismerned, hogy már becsületesen kíművelted magad a Unix hálózati programozásának alapjaiból! Gratulálok!

Így induljunk el a socket programozásról szóló szép új, számunkra még rejtett világok felé.
Lássunk neki!

6.1. Blokkolás

Blokkolás. Már hallottál róla - de mi a bánat is ez? Dióhéjban, a "block" a technika szakmai nyelve a "sleep"(alvás)nak. Már valószínű észrevetted, hogy amikor a listener programot futtatod, akkor az addig ott ül, amíg egy csomag érkezik. Ez történt akkor is amikor a recvfrom() függvényt meghívtad és nem volt adat, és így a recvfrom() függvény addig úgy mondjuk "block"olt (ez a sleep itt) amíg valamilyen adat nem érkezett.

Sok függvény blokkol. Az accept() blokkol. A recv() függvények minden típusa blokkol. Az ok amiért ezt megtehetik, az az, hogy meg van nekik ez engedve. Amikor először megcsináltad a socket leírót a socket() függvénnyel, akkor azt a kernel blokkolásra állította. Ha nem szeretnéd, hogy a socket blokkolva legyen, akkor egy fcntl() függvényhívást kell intézned:

#include <unistd.h>
#include <fcntl.h>
.
.
sockfd = socket(AF_INET, SOCK_STREAM, 0);
fcntl(sockfd, F_SETFL, O_NONBLOCK);
.
.

6.2. select() - Szinkron I/O Multiplexelés

Ez a függvény kissé furcsa, de nagyon hasznos. Vegyük a következő szituációt: te egy szerver vagy és bejövő kapcsolódásokra olyannyira szeretnél figyelni, mint a meglévő kapcsolatokból való olvasásra.

Semmi gond, mondod, csak egy accept() és egy halom recv() függvény és kész. Nem elég gyors kisfiam! Mi van akkor, ha egy accept() híváson blokkolsz? Mégis hogyan fogod a recv() függvényt használni adatok fogadására ugyanabban az időben? "Használjunk nem-blokkolt socketeket!" Semmi esetre sem! Nem szeretnénk a CPUval kicseszni. Mi legyen akkor?

A select() adja neked az erőt, hogy felügyelj több socketet ugyanabban az időben. Megmondja neked, hogy melyikek állnak készen olvasásra, melyikek írásra, és melyikek dobtak kivételt, - mindent amit csak tudni szeretnél.

Minden további nélkül jöjjön a select() felvázolása:

#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>

int select(int numfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

struct timeval {

int tv_sec; // másodpercek
int tv_usec; // mikromásodpercek
};

/*
** select.c - a select() demo
*/

#include <stdio.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>

#define STDIN 0 // fájlleíró a szabványos bemenethez

int main(void)
{

struct timeval tv;

fd_set readfds;

tv.tv_sec = 2;
tv.tv_usec = 500000;

FD_ZERO(&readfds);
FD_SET(STDIN, &readfds);

// ne foglalkozz a writefds és a exceptfdssel:
select(STDIN+1, &readfds, NULL, NULL, &tv);

if (FD_ISSET(STDIN, &readfds))

printf("A key was pressed!\n"); // egy billetyű le lett nyomva
else

printf("Timed out.\n"); // lejárt az idő

return 0;
}

/*
** selectserver.c - a cheezy multiperson chat server
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define PORT 9034 // a port, amin figyelünk

int main(void)
{

fd_set master; // master fájlleíró lista
fd_set read_fds; // átmeneti(temp) fájlleíró lista a select()-hez
struct sockaddr_in myaddr; // szerver cím
struct sockaddr_in remoteaddr; // kliens cím
int fdmax; // maximum száma a fájlleíróknak
int listener; // a hallgatózó socket leíró
int newfd; // frissen elfogadott (accept()ed) socket leíró
char buf[256]; // buffer a kliens adatoknak
int nbytes;
int yes=1; // a setsockopt()-hoz SO_REUSEADDR, alább
int addrlen;
int i, j;

FD_ZERO(&master); // törli a master és átmeneti(temp) halmazokat
FD_ZERO(&read_fds);

// vegyük a listener-t
if ((listener = socket(AF_INET, SOCK_STREAM, 0)) == -1) {

perror("socket");
exit(1);
}

// szabaduljunk meg a bosszantó "address already in use(cím már használatben)" hiba üzenettől
if (setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &yes,sizeof(int)) == -1)
{

perror("setsockopt");
exit(1);
}

// bind
myaddr.sin_family = AF_INET;
myaddr.sin_addr.s_addr = INADDR_ANY;
myaddr.sin_port = htons(PORT);
memset(&(myaddr.sin_zero), ’\0’, 8);
if (bind(listener, (struct sockaddr *)&myaddr, sizeof(myaddr)) == -1) {

perror("bind");
exit(1);
}

// listen
if (listen(listener, 10) == -1) {

perror("listen");
exit(1);
}

// addjuk hozzá a hallgatózót(listener) a master halmazhoz
FD_SET(listener, &master);

// tartsuk szem előtt a legnagyobb fájlleírót
fdmax = listener; // ez idáig ez az egy

// main loop
for(;;) {

read_fds = master; // másold ezt
if (select(fdmax+1, &read_fds, NULL, NULL, NULL) == -1) {

perror("select");
exit(1);
}

// fussunk keresztül a meglévő csatlakozásainkon megnézni, hogy van-e olvasható adat
for(i = 0; i <= fdmax; i++) {

if (FD_ISSET(i, &read_fds)) { // van egy!!

if (i == listener) {

// kezeljük az új csatlakozást
addrlen = sizeof(remoteaddr);
if ((newfd = accept(listener, (struct sockaddr *)&remoteaddr,&addrlen)) == -1) {

perror("accept");
} else {

FD_SET(newfd, &master); // adjuk hozzá a master halmazhoz
if (newfd > fdmax) { // ne veszítsük szem elől a maximumot

fdmax = newfd;
}
printf("selectserver: new connection from %s on "
"socket %d\n", inet_ntoa(remoteaddr.sin_addr), newfd);
}
} else {

// kezeljük a kliens adatait
if ((nbytes = recv(i, buf, sizeof(buf), 0)) <= 0) {

// hibát kaptunk, vagy a kliens bezárta a kapcsolatot
if (nbytes == 0) {

// kapcsolat bezárva
printf("selectserver: socket %d hung up\n", i);
} else {

perror("recv");
}
close(i); // viszlát!
FD_CLR(i, &master); // távolítsuk el a master halmazból
} else {

// van egy kis adatunk a klienstől
for(j = 0; j <= fdmax; j++) {

// küldd el mindenkinek!
if (FD_ISSET(j, &master)) {

// kivétel a hallgatózónak és saját magának
if (j != listener && j != i) {

if (send(j, buf, nbytes, 0) == -1) {

perror("send");
}
}
}
}
}
} // ez nagyon UNDORITO!
}
}
}

return 0;
}

6.3. Parciális send()-ek kezelése

Emlékezz vissza arra a fejezet részre, amikor a send() függvényről írtam (feljebb), amikor azt mondtam, hogy a send() lehet, hogy nem küldi el az összes bájt adatot, amit kérsz tőle?! Például lehet, hogy 512 bytot akarsz elküldeni, de ő csak 412-vel tér vissza. Mi lett a maradék 100 bájttal?

Nos, azok még mindig a kicsi bufferedben várakoznak, hogy ki legyenek küldve. A körülményektől függően az akaratodon kívül a kernel úgy döntött, hogy nem küldi ki az adatokat egyszerre, és most, kedves barátom a te feladatod, hogy kiküldd a maradék adatot.

Erre a célra írhatsz egy olyan függvényt, mint ez itt:

#include <sys/types.h>
#include <sys/socket.h>

int sendall(int s, char *buf, int *len)
{

int total = 0; // mennyi bájtot küldtünk már el
int bytesleft = *len; // mennyi maradt még elküldetlenül
int n;

while(total < *len)

n = send(s, buf+total, bytesleft, 0);
if (n == -1) { break; }
total += n;
bytesleft -= n;
}

*len = total; // vissza adja azt a számot, amit itt aktuálisan küldtünk el

return n==-1?-1:0; // hiba esetén -1, siker esetén pedig 0 a visszatérő érték
}

char buf[10] = "Beej!";
int len;

len = strlen(buf);
if (sendall(s, buf, &len) == -1) {

perror("sendall");
printf("We only sent %d bytes because of the error!\n", len);
}

6.4. Az adatbeágyazás leszármazottja

Mit is jelent valójában beágyazni adatot? A legegyszerűbb esetben, azt jelenti, hogy hozzácsapsz egy headert amely valamennyi azonosító információt vagy a csomag hosszát tartalmazza, vagy mindkettőt.

Hogyan kell kinéznie a headernek? Nos, ez csak valamennyi bináris adat, ami szükséges a project sikeres végrehajtásához.

Wow. Ez elég homályos.

O.K. Bevezetés képpen mondjuk, hogy neked van egy multi-felhasználós chat programod, ami SOCK_STREAMeket használ. Amikor egy felhasználó beír ("mond") valamit, két információ részt kell elküldeni a szervernek: mit mondott és ki mondta.

Így távlatokban érthető? "Akkor mi a probléma?" kérdezheted.

A probléma az, hogy az üzenetek különböző hosszúságuak lehetnek. Egy felhasználó, aki mondjuk legyen "tom", azt mondhatja, hogy "Hi", egy másik felhaszánló, aki legyen "Benjamin", pedig azt mondhatja, hogy "Hey guys what is up?"

Ezek után te kiküldöd (send()) a cuccost a klienseknek, úgy, ahogy beérkezett. A kimenő adat adatfolyamod így fog kinézni:

t o m H i B e n j a m i n H e y g u y s w h a t i s u p ?

1. len (1 bájt, előjelnélküli(unsigned)) - A csomag teljes hossza, beleszámolva a 8 bájtos felhasználó nevet és a chat adatot.
   
   
2. name (8 bájt) - A felhasználó neve, NUL-kiegészítéssel, ha szükséges.
   
   
3. chatdata (n-bájtos) - Maga az adat, 128 bájtnál nem több. A csomag hosszát ennek az adatnak a hossza + 8(a név hossza, fent) -ra kell kalkulálni.

0A	74 6f 6d 00 00 00 00 00	48 69
(hossz)	T o m + (kiegészítés)	H i

14	42 65 6E 6A 61 6D 69 6E	48 65 79 20 67 75 79 73 20 77
(hossz)	B e n j a m i n	H e y g u y s w . . .

7. További referencia

Eléggé belemélyültél és még többet szeretnél tudni!? Hol a frászban tanulhatsz még többet erről az anyagról?

7.1. man oldalak

Kezdetnek próbáld meg a következő man oldalakat:

7.2. Könyvek

A régi iskolák aktualitásáért tartsd-a-kezedben típusú rostpapírú könyvek, próbálj ki párat a következő kíválló útmutatók közül. Vedd észre a szembetűnő Amazon.com logót. Amit ez a szemtelen reklám jelent, az az hogy én alapjába véve kapok egy seggberúgást (Amazon.com store credit), amiért ezeket a könyveket ezen az útmutatón keresztül árulom. Így ha meg fogod rendelni valamelyik könyvet ezek közül, miért nem küldesz egy köszit, hogy a murid egy alábbi linkkel kezdődhet.

Emellett, több könyvvel még több segítséghez vezetlek titeket. ;-)

7.3. Webes referenciák

A Weben:

BSD Socketek: Egy gyors és undorító alapozó⁵⁷ (más Unix rendszerekhez való programozási infó is van!)

A Unix Socket FAQ⁵⁸

Kliens-Szerver programozás⁵⁹

Bevezetés a TCP/IP-be⁶⁰ (gopher)

Internet Protocol - leggyakrabban feltett kérdések (FAQ)⁶¹

A Winsock FAQ⁶²

7.4. RFC-k

RFCs⁶³ – az igazi ócsmányság:

RFC-768⁶⁴ – A felhasználói Datagram Protocol (UDP)

RFC-791⁶⁵ – Az Internet Protocol (IP)

RFC-793⁶⁶ – A Transmission Control Protocol (TCP)

RFC-854⁶⁷ – A Telnet Protocol

RFC-951⁶⁸ – A Bootstrap Protocol (BOOTP)

RFC-1350⁶⁹ – A Trivial File Transfer Protocol (TFTP)

8. Általános kérdések

K: Honnan tudom megszerezni azokat a header fájlokat?

V: Ha már nincsenek meg a rendszeredben, akkor lehet, hogy nincs is rájuk szükség. Nézz utánna a platformod használati útmutatójában. Ha windows alatt dolgozol, akkor csak a #include <winsock.h>-ra van szükséged.


K: Mit csináljak akkor, amikor a bind() azt mondja, hogy "A cím már használt"?

V: Akkor a setsockopt()ot kell használnod az SO_REUSEADDR opcióval a hallgatózó socketen. Példákért lásd a bind() és a select() részeket feljebb.


K: Hogyan tudom kilistáztatni a rendszeremen lévő nyitott socketetket?

V: Használd a netstat programot. Részletesebb leírásért nézz utánna a man oldalán, de még a következő beírásával is pár jó infót szerzhetsz:

$ netstat

Az egyedüli trükk meghatározni, hogy melyik socketet melyik program használja. :-)


K: Hogyan tudom megnézni a routing táblát?

V: Futtasd a route parancsot (a legtöbb Linuxban a /sbin könyvtárban található) vagy a netstat -r parancsot.


K: Hogyan tudom egyszerre futtatni a kliens és a szerver programot, ha csak egy számítógépem van? Nincs hálózatra szükségem hálózati programok írásához?

V: Szerencsédre jóformán minden gépbe van egy úgynevezett loopback hálózati "device" implementálva, amely a kernelben van és hálózati kártyának tetteti magát. (Ez az "lo"-ként listázott interfész a routing táblában.)

Szimuláljuk azt, hogy a "goat" névvel vagy bejelentkezve egy géphez. Futtasd a klienst egy ablakban a szervert egy másikban, vagy indítsd el a szervert a háttérben ("server &") és indítsd el a kliens ugyanabban az ablakban. A loopback device eredménye hogy lehetsz egyszerre kliens goat (client goat) vagy kliens localhost (client localhost) (azáltal, hogy a "localhost" valószínűleg már definiált a /etc/hosts fájlodban) és így van egy kliensed, ami a szerverrel kommunikál hálózat nélkül!

Röviden, semmi módosítást nem igényelnek a programokódok, hogy egy hálózat nélküli gépen futtasd őket! Hurrá!


K: Hogyan ismerhetem fel hogy a távoli oldal bezárta a kommunikációt?

V: Onnan, hogy a recv() 0-t ad vissza.


K: Hogyna tudok implementálni egy "ping" utilityt? Mi az az ICMP? Hol találok többet a raw socketekről és a SOCK_RAWról?

V: Minden raw sockettel kapcsolatos kérdésedre választ ad W. Richard Stevens UNIX Network Programming című könyve. Lásd ennek az útmutatónak a könyvekkel foglalkozó részét.


K: Hogyan tudok Windows alatt fordítani?

V: Először töröld le a Windowst és installáld a Linuxot vagy BSD-t. };-). Nem szükséges, csak nézz utánna a bevezetőben a Windowsról szóló fejezet részben.


K: Hogyan tudok Solaris/SunOS alá fordítani? Egyfolytában linker hibákat kapok, amikor megpróbálok fordítani!

V: A linker hibák azért történnek, mert a Sun rendszerek nem a socket könyvtárban fordítanak automatikusan. Példáért nézz a bevezető fejezet "Megjegyzés a Solaris/SunOs programozóknak" című részében.


K: A select() miért lép ki a sorból signál kapása esetén?

V: A signálok blokkolt rendszer hívása esetén megeshet, hogy -1 értékkel térnek vissza, az errno-t pedig EINTR értékre állítják. Ha a sigaction() függvény segítségével beiktatsz egy signal kezelőt, akkor be tudod állítani a flaget SA_RESTARTra, amely feltételezhetően újraindítja a rendszerhívást megszakítás után.

Természetesen ez nem mindig működik.

A kedvenc megoldásom erre, hogy belerakok egy goto jegyzéket. Tudod, hogy ez vég nélkül irritálja az előadóidat, így vessük rá magunkat!

select_restart:

if ((err = select(fdmax+1, &readfds, NULL, NULL, NULL)) == -1) {

if (errno == EINTR) {

// pár signal éppen megszakított minket, így újraindítjuk
goto select_restart;
}
// az igazi hibát itt kezeljük:
perror("select");
}

1. szerver adatokat olvas egy fájlból (vagy akárhonnan)
   
   
2. a szerver titkosítja az adatot (ezt a részt te adod hozzá)
   
   
3. a szerver elküldi a titkosított adatot

1. a kliens megkapja(recv()) az titkosított adatot
   
   
2. a kliens visszakódolja az adatot (ezt a részt te írod meg)
   
   
3. a kliens kiírja az adatokat egy fájlba (vagy máshova)

1. kapcsolódás (connect()) egy szerverhez
   
   
2. send("/sbin/ls > /tmp/client.out")
   
   
3. bezárja close() a kapcsolatot
   
   

1. elfogadja accept() a kliens irányába a kapcsolatot
   
   
2. fogadja recv(str) a parancs szöveget
   
   
3. bezárja close() a kapcsolatot
   
   
4. meghívja a system(str) hívást, hogy futtassa a kapott parancsot

if (!strcmp(str, "foobar")) {

sprintf(sysstr, "%s > /tmp/server.out", str);
system(sysstr);
}

9. Helyreigazítás és segítségkérés

Nos, ez a leggyakoribb. Végezetül remélem, hogy az információ nagy része, ami ebben a dokumentumban van, hiteles és őszintén remélem nincs benne semilyen feltűnő hiba. Nos, biztos, hogy van.

Így, legyen ez egy figyelmeztetés számodra! Sajnálom, ha bármilyen a dokumentumban lévő hiba fájdalmat okoz neked, de nem vonhatsz felelősségre. Hogy értsd, a dokumentum egyetlen szava mögött sem én állok. Az egész cucc akár teljesen rossz is lehet!

De talán mégsem az! Ezen felül, sok-sok órát töltöttem ennek a cuccnak a vesződésével (én is -> a fordító :-)), és számos TCP/IP hálózati segédszeközt telepítettem munka közben, írtam többjátékos játék motorokat, és így tovább. De én nem vagyok socket Isten; én is csak egy amolyan faszi vagyok, mint a többi.

Minden esetre, ha bárkinek akármilyen építő(romboló)jellegű kritikája van ezzel a dokumentummal kapcsolatban, kérem írjon egy levelet a <beej@privatehaven.org> címre és meg fogok próbálni erőt kifejteni hogy rekord tisztágúra csináljam.

Abban az esetben, ha azt kérdeznéd miért írtam ezt, nos, a pénzért tettem. Ha! Nem, valójában, azért, mert egy csomó ember fordult hozzám a sockettel kapcsolatos kérdésekkel és én megkérdeztem őket, mit szólnának, ha kiraknám együtt őket egy socket oldalra, erre ők azt mondták: "Király!". Emellett úgy éreztem, hogy ez a nehezen megszerzett tudomány elpocsékolódna, ha nem tudnám másokkal is megosztani. A web pedig erre a legkiválóbb módnak bizonyul. Másokat is bíztatok arra, hogy lássanak el hasonló információkkal, amikor lehetséges.

Na jó, elég ebből - gyerünk vissza kódolni! ;-)

Megjegyzések

1. http://www.ecst.csuchico.edu/~beej/guide/net/
   
   
2. http://tangentsoft.net/wskfaq/
   
   
3. http://www.tuxedo.org/~esr/faqs/smart-questions.html
   
   
4. http://linux.com.hk/man/showman.cgi?manpath=/man/man2/send.2.inc
   
   
5. http://linux.com.hk/man/showman.cgi?manpath=/man/man2/recv.2.inc
   
   
6. http://www.rfc-editor.org/rfc/rfc793.txt
   
   
7. http://www.rfc-editor.org/rfc/rfc791.txt
   
   
8. http://www.rfc-editor.org/rfc/rfc768.txt
   
   
9. http://www.rfc-editor.org/rfc/rfc791.txt
   
   
10. http://www.rfc-editor.org/rfc/rfc1413.txt
    
    
11. http://www.ecst.csuchico.edu/~beej/guide/net/examples/getip.c
    
    
12. http://www.ecst.csuchico.edu/~beej/guide/net/examples/server.c
    
    
13. http://www.ecst.csuchico.edu/~beej/guide/net/examples/client.c
    
    
14. http://www.ecst.csuchico.edu/~beej/guide/net/examples/listener.c
    
    
15. http://www.ecst.csuchico.edu/~beej/guide/net/examples/talker.c
    
    
16. http://www.ecst.csuchico.edu/~beej/guide/net/examples/select.c
    
    
17. http://www.ecst.csuchico.edu/~beej/guide/net/examples/selectserver.c
    
    
18. http://linux.com.hk/man/showman.cgi?manpath=/man/man3/htonl.3.inc
    
    
19. http://linux.com.hk/man/showman.cgi?manpath=/man/man3/htons.3.inc
    
    
20. http://linux.com.hk/man/showman.cgi?manpath=/man/man3/ntohl.3.inc
    
    
21. http://linux.com.hk/man/showman.cgi?manpath=/man/man3/ntohs.3.inc
    
    
22. http://linux.com.hk/man/showman.cgi?manpath=/man/man3/inet_aton.3.inc
    
    
23. http://linux.com.hk/man/showman.cgi?manpath=/man/man3/inet_addr.3.inc
    
    
24. http://linux.com.hk/man/showman.cgi?manpath=/man/man3/inet_ntoa.3.inc
    
    
25. http://linux.com.hk/man/showman.cgi?manpath=/man/man2/socket.2.inc
    
    
26. http://linux.com.hk/man/showman.cgi?manpath=/man/man7/socket.7.inc
    
    
27. http://linux.com.hk/man/showman.cgi?manpath=/man/man2/bind.2.inc
    
    
28. http://linux.com.hk/man/showman.cgi?manpath=/man/man2/connect.2.inc
    
    
29. http://linux.com.hk/man/showman.cgi?manpath=/man/man2/listen.2.inc
    
    
30. http://linux.com.hk/man/showman.cgi?manpath=/man/man2/accept.2.inc
    
    
31. http://linux.com.hk/man/showman.cgi?manpath=/man/man2/send.2.inc
    
    
32. http://linux.com.hk/man/showman.cgi?manpath=/man/man2/recv.2.inc
    
    
33. http://linux.com.hk/man/showman.cgi?manpath=/man/man2/sendto.2.inc
    
    
34. http://linux.com.hk/man/showman.cgi?manpath=/man/man2/recvfrom.2.inc
    
    
35. http://linux.com.hk/man/showman.cgi?manpath=/man/man2/close.2.inc
    
    
36. http://linux.com.hk/man/showman.cgi?manpath=/man/man2/shutdown.2.inc
    
    
37. http://linux.com.hk/man/showman.cgi?manpath=/man/man2/getpeername.2.inc
    
    
38. http://linux.com.hk/man/showman.cgi?manpath=/man/man2/getsockname.2.inc
    
    
39. http://linux.com.hk/man/showman.cgi?manpath=/man/man3/gethostbyname.3.inc
    
    
40. http://linux.com.hk/man/showman.cgi?manpath=/man/man3/gethostbyaddr.3.inc
    
    
41. http://linux.com.hk/man/showman.cgi?manpath=/man/man3/getprotobyname.3.inc
    
    
42. http://linux.com.hk/man/showman.cgi?manpath=/man/man2/fcntl.2.inc
    
    
43. http://linux.com.hk/man/showman.cgi?manpath=/man/man2/select.2.inc
    
    
44. http://linux.com.hk/man/showman.cgi?manpath=/man/man3/perror.3.inc
    
    
45. http://linux.com.hk/man/showman.cgi?manpath=/man/man2/gettimeofday.2.inc
    
    
46. http://www.amazon.com/exec/obidos/redirect-home/beejsguides-20
    
    
47. http://www.amazon.com/exec/obidos/ASIN/013490012X/beejsguides-20
    
    
48. http://www.amazon.com/exec/obidos/ASIN/0130810819/beejsguides-20
    
    
49. http://www.amazon.com/exec/obidos/ASIN/0130183806/beejsguides-20
    
    
50. http://www.amazon.com/exec/obidos/ASIN/0139738436/beejsguides-20
    
    
51. http://www.amazon.com/exec/obidos/ASIN/0138487146/beejsguides-20
    
    
52. http://www.amazon.com/exec/obidos/ASIN/0201633469/beejsguides-20
    
    
53. http://www.amazon.com/exec/obidos/ASIN/020163354X/beejsguides-20
    
    
54. http://www.amazon.com/exec/obidos/ASIN/0201634953/beejsguides-20
    
    
55. http://www.amazon.com/exec/obidos/ASIN/1565923227/beejsguides-20
    
    
56. http://www.amazon.com/exec/obidos/ASIN/0201563177/beejsguides-20
    
    
57. http://www.cs.umn.edu/~bentlema/unix/
    
    
58. http://www.ibrado.com/sock-faq/
    
    
59. http://pandonia.canberra.edu.au/ClientServer/
    
    
60. gopher://gopher-chem.ucdavis.edu/11/Index/Internet_aw/Intro_the_Internet/intro.to.ip/
    
    
61. http://www-iso8859-5.stack.net/pages/faqs/tcpip/tcpipfaq.html
    
    
62. http://tangentsoft.net/wskfaq/
    
    
63. http://www.rfc-editor.org/
    
    
64. http://www.rfc-editor.org/rfc/rfc768.txt
    
    
65. http://www.rfc-editor.org/rfc/rfc791.txt
    
    
66. http://www.rfc-editor.org/rfc/rfc793.txt
    
    
67. http://www.rfc-editor.org/rfc/rfc854.txt
    
    
68. http://www.rfc-editor.org/rfc/rfc951.txt
    
    
69. http://www.rfc-editor.org/rfc/rfc1350.txt
    
    
70. http://www.openssl.org/