TCP/IP en Poorten
door Roland Leurs

Hoe werkt TCP/IP en wat zijn nou die poorten waar iedereen het steeds over heeft? Zijn dat connectoren waar je een steker in stopt en dan communiceren maar of hoe zit dat? Dit zijn een aantal vragen die de grondslag waren voor een presentatie op een van onze regioavonden in Sittard. Op veler verzoek volgt hier nogmaals het verhaal.

De behandelde onderwerpen zijn:

TCP/IP is een protocol suite die ontwikkelt is door het Amerikaanse Ministerie van Defensie. Deze suite biedt een aantal protocollen, zeg maar afspraken, om computersystemen met elkaar te laten communiceren. Deze systemen kunnen dicht bij elkaar staan en via één kabel met elkaar verbonden zijn, maar ook is het mogelijk dat deze systemen duizenden kilometers uit elkaar staan en dat daar diverse systemen tussen zitten die er wel voor zorgen dat twee systemen met elkaar kunnen communiceren.

Aplicatie	FTP, Telnet, e-mail
Transport	TCP, UDP
Internet	IP, ICMP, RIP, ARP
Host to network	LAN, Packet Radio

Tabel 1:   TCP/IP   model

Kenners herkennen hier meteen het OSI model in, maar dit model wijkt principieel af, de onderste twee lagen van het OSI model zijn samengevoegd in de Host-to-network laag en TCP/IP kent geen session en presentation layers.

Kort omschreven hebben de lagen de volgende functies:

We zien hier twee systemen die met elkaar willen communiceren. Als basis van de communicatie worden de hardware adressen van de netwerkkaarten gebruikt. Deze adressen zijn 48 bits lang (6 bytes) waarbij de hoogste drie bytes gereserveerd zijn om de fabrikant aan te duiden, en de laagste drie bytes zijn een unieke code die door de fabrikant toegewezen wordt. Indien een fabrikant door zijn codes heen is, kan hij een nieuwe “fabrikant-code” aanvragen.

De software in de tweede laag is in staat om aan de hand van het IP adres te bepalen of een systeem op hetzelfde netwerk aangesloten is of op een extern netwerk zit. Door het ARP (address resolution protocol) wordt de vraag “wie heeft adres x.x.x.x op het netwerk gesteld. Indien een systeem dit adres heeft zal dit antwoorden met: “Dat ben ik, stuur maar naar MAC adres "yy.yy.yy.yy.yy.yy ”. Daarna kan de communicatie beginnen en worden de pakketten verzonden.

In bovenstaande afbeelding is het op vaststellen van het benodigde MAC adres goed zichtbaar.

Enkele voorbeelden:

20/21	FTP	80	HTTP
22	SSH	110	POP3
23	Telnet	443	HTTPS
25	SMTP	6502	NetAtom

Een complete lijst van vastgelegde well-known ports is te vinden op het internet en wel op

"http://www.ietf.org/rfc/rfc1700.txt" .
5. De Atom en TCP/IP

/* atomserver.c */

#include <asm/io.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<unistd.h>
#include<stdlib.h>
#include<stdio.h>
#define BASEPORT 0x31C

main()
{
int cont,create_socket,new_socket,addrlen;

unsigned int b;
int bufsize = 32;
unsigned char *buffer = malloc(bufsize);
struct sockaddr_in address;

printf("Atom server starting\n");
/* Get access to the ports */
if (ioperm(BASEPORT, 4, 1)) {perror("ioperm"); exit(1);}
if ((create_socket = socket(AF_INET,SOCK_STREAM,0)) > 0)
printf("The socket was created\n");
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons(6502);
if (bind(create_socket,(struct sockaddr *)&address,sizeof(address)) == 0)
printf("Binding Socket\n");
listen(create_socket,3);
printf("Waiting for client\n");
addrlen = sizeof(struct sockaddr_in);
new_socket = accept(create_socket,(struct sockaddr *)&address,&addrlen);
if (new_socket > 0){
printf("The Client %s is connected...\n",inet_ntoa(address.sin_addr));
}
strcpy(buffer, "Welcome to NetAtom server\n");
send(new_socket,buffer,bufsize,0);
do{
recv(new_socket,buffer,bufsize,0);
if (buffer[0] < 0x80)
{ // read from port
buffer[0]=inb(BASEPORT+buffer[0]);
}
else
{ // write to port
outb(buffer[1], BASEPORT+(0x7F&buffer[0]) );
}
send(new_socket,buffer,1,0);
}while(strcmp(buffer,"/q")); //user ‘q’ to quit
close(new_socket);
close(create_socket);
/* We don't need the ports anymore */
if (ioperm(BASEPORT, 4, 0)) {perror("ioperm"); exit(1);}
printf("Atom server shut down\n");
}

Het client gedeelte ziet er als volgt uit:

/* atomio.h, included from atom.c */

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

int create_socket;
int bufsize = 32;
// char *buffer=malloc(bufsize);
struct sockaddr_in address;

unsigned int readport(int port)
{
char buffer[bufsize];
buffer[0]=port; buffer[1]=0x00;
send(create_socket, buffer, 2, 0);
recv(create_socket, buffer, bufsize, 0);
return(buffer[0]);
}

void writeport(unsigned char data, int port)
{
char buffer[bufsize];
buffer[0]=port+0x80; buffer[1]=data;
send(create_socket, buffer, 2, 0);
recv(create_socket, buffer, bufsize, 0);
}

void openatom(char *serveraddr)
{
char buffer[bufsize];
/* Set up TCP connection to server */
printf("Atom client starting\n");
if ((create_socket = socket(AF_INET,SOCK_STREAM,0)) > 0)
printf("The Socket was created\n");
address.sin_family = AF_INET;
address.sin_port = htons(6502);
inet_pton(AF_INET, serveraddr, &address.sin_addr);
if (connect(create_socket,(struct sockaddr *)&address,sizeof(address)) == 0)
printf("The connection was accepted with the server %s...\n",inet_ntoa(address.sin_addr));
recv(create_socket, buffer, bufsize, 0);
printf("%s", buffer);
/* initialize the atom */
writeport(0xB4, 3);
writeport(0x0F, 3);
usleep(100000);
writeport(0x0E, 3);
usleep(100000);
writeport(0x0F, 3);
}

int readbyte(void)
{
while(!(readport(2) & 0x20)) ;
return readport(0);
}

int sendbyte(int byte)
{
while(!(readport(2) & 0x02)) ;
writeport(byte, 1);
return(byte);
}

void closeatom(void)
{
char buffer[bufsize];
buffer[0]='/'; buffer[1]='q';
send(create_socket, buffer, 2, 0);
recv(create_socket, buffer, bufsize, 0);
close(create_socket);
printf("Atom client shut down\n");
}

void resetatom(int msg)
{
if (msg)
{
printf("\n\n\n");
printf("###################################\n");
printf("# PRESS ANY KEY TO RESET THE ATOM #\n");
printf("###################################\n");
getchar();
}
writeport(0x0E, 3);
usleep(100000);
writeport(0x0F, 3);
}