chapter 8 elementary udp socket n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Chapter 8 Elementary UDP Socket PowerPoint Presentation
Download Presentation
Chapter 8 Elementary UDP Socket

Loading in 2 Seconds...

play fullscreen
1 / 28

Chapter 8 Elementary UDP Socket - PowerPoint PPT Presentation


  • 410 Views
  • Uploaded on

Chapter 8 Elementary UDP Socket. Contents. recvfrom and sendto Function UDP Echo Server( main, de_echo Function) UDP Echo Client( main, de_cli Function) Lost datagrams Verifying Received Response Sever not Running Connect Function with UDP Lack of Flow Control with UDP

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Chapter 8 Elementary UDP Socket' - joaquin


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
contents

Contents

recvfrom and sendto Function

UDP Echo Server( main, de_echo Function)

UDP Echo Client( main, de_cli Function)

Lost datagrams

Verifying Received Response

Sever not Running

Connect Function with UDP

Lack of Flow Control with UDP

Determining Outgoing Interface with UDP

TCP and UDP Echo Server Using select

8 1 introduction

8.1 Introduction

connectionless

unreliable

datagram protocol

popular using

DNS(the Domain Name System)

NFS(the Network File System)

SNMP(Simple Network Management Protocol)

slide4

UDP Server

socket( )

bind( )

UDP Client

socket( )

recvfrom( )

block until datagram

received from a client

sendto( )

data(request)

Process request

recvfrom( )

data(reply)

sendto( )

close( )

Socket functions for UDP client-server

8 2 recvfrom and sendto functions

8.2 recvfrom and sendto Functions

#include<sys/socket.h>

ssize_t recvfrom(int sockfd, void *buff, size_t nbyte, int flag,

struct sockaddr *from, socklen_t *addrlen);

ssize_t sendto(int sockfd, const void *buff, size_t nbyte, int flag,

const struct sockaddr *to, socklen_t addrlen);

Both return: number of bytes read or written if OK,-1 on error

8 3 udp echo server main function

8.3 UDP Echo Server: main Function

fgets

recvfrom

sendto

UDP

client

stdin

UDP

server

stdout

fputs

sendto

recvfrom

#include “unp.h”

int main(int argc, char **argv)

{

int sockfd;

struck sockaddr_in servaddr,cliaddr;

sockfd=Socket(AF_INET,SOCK_DGRAM,0);

bzero(&servaddr,sizeof(servaddr));

servaddr.sin_fammily=AF_INET;

servaddr.sin_addr.s_addr=htonl(INADDR_ANY);

servaddr.sin_port=htons(SERV_PORT);

bind(sockfd, (SA *) &servaddr,sizeof(servaddr));

dg_echp(sockfd, (SA *) &cliaddr,sizeof(cliaddr));

}

Simple echo client-server using UDP

UDP echo server

8 4 udp echo server dg echo function

8.4 UDP Echo Server:dg_echo Function

#include “unp.h”

void dg_echo(int sockfd, SA *pcliaddr, socklen_t clilen)

{

int n;

socklen_t len;

char mesg[MAXLINE];

for( ; ; ) {

len=clilen;

n=Recvfrom(sockfd, mseg, MAXLINE, 0, pcliaddr, &len);

sendto(sockfd, mesg, n, 0, pcliaddr, len);

}

}

dg_echo funtion: echo lines on a datagram socket.

slide8

1.This function never terminates.

2.This function provides an iterative, not a concurrent

server as we had with TCP

listening

server

server

child

server

child

connection

connection

fock

client

fock

client

TCP

TCP

TCP

connection

connection

Summary of TCP client-server with two clients.

slide9

server

client

client

Socket receive

buffer

UDP

UDP

UDP

datagram

datagram

Summary of UDP client-server with two clients.

8 5 udp echo client main function

8.5 UDP Echo client: main Function

#include “unp.h”

int main(int argc, char **argv)

{

int sockfd;

struct sockaddr_in servaddr;

if (argc != 2)

err_quit( “usage : udpcli <Ipaddress>”);

bzero(&servaddr, sizeof(servaddr);

servaddr.sin_family = AF_INET;

servaddr.sin_port = htons(SERV_PORT);

Inet_pton(AF_INET, argv[1], &servaddr.sin_addr);

sockfd = Socket(AF_INET, SOCK_DGRAM, 0);

dg_cli(stdin, sockfd, (SA *) &servaddr, sizeof(servaddr);

exit(0);

}

8 6 udp echo client dg cli function

8.6 UDP Echo Client: dg_cli Function

#include “unp.h”

void dg_cli(FILE *fp, int sockfd, const SA *pservaddr, soklen_t servlen)

{

int n;

char sendline[MAXLINE], recvline[MAXLINE+1];

while(Fgets(sendline, MAXLINE, fp) != NULL) {

sendto(sockfd, sendline, strlen(sendline), 0, pservaddr, servlen);

n = Recvfrom(sockfd, recvline, MAXLINE, 0, NULL, NULL);

recvline[n] = 0; /* null terminate */

Fputs(recvline,stdout);

}

}

dg_cli function: client processing loop

8 7 lost datagrams

8.7 Lost Datagrams

If the client datagram arrives at the server but the server’s reply is lost, the client will again block forever in its call to recvfrom.

The only way to prevent this is to place a timeout on the recvfrom.

8 8 verify received response

8.8 Verify Received Response

#include “unp.h”

void dg_cli(FILE *fp, int sock, const SA *pseraddr, socklen_t servlen)

{

int n;

char sendline[MAXLINE], recvline[MAXLINE];

socklen_t len;

struct sockaddr *preply_addr;

preply_addr = Malloc(servlen);

while(Fget(sendline, MAXLINE, fp) ! = NULL) {

Sendto(sockfd,sendline, strlen(sendline), 0, pservaddr, servlen);

len = servlen;

n = Recvfrom(sockfdm, recvline, MAXLINE, 0, preply_addr,&len)

continue

slide14

If(len != servlen || memcmp(pservaddr, preply_addr, len) != 0) {

printf(“reply from %s (ignore)\n”,

Sock_ntop(preply_addr, len);

continue;

}

recvline[n] = 0; /*NULL terminate */

Fputs(recvline, stdout);

}

}

Version of dg_cli that verifies returned socket address.

Bsdi.kohala.com has address 206.62.226.35

Bsdi.kohala.com has address 206.62.226.66

Solaris % udpcli02 206.62.226.66

hello

reply from 206.62.226.35.7 (ignore)

goodbye

reply from 206.62.226.35.7 (ignore)

The server has not bound an IP address

to its socket, the kernel choose the source address for the IP datagram. It is chosen

to be the primary IP address of the outgoing interface.

8 9 server not running

8.9 Server Not Running

Client blocks forever in the call to recvfrom.

ICMP error is asynchronous error.

The basic rule is that asynchronous errors are not returned for UDP sockets unless the socket has been connected.

8 11 connect function with udp

8.11 connect Function with UDP

This does not result in anything like a TCP connection: there is no three-way handshake.

Instead, the kernel just records the IP address and port number of the peer.

With a connect UDP socket three change:

1. We can no long specify the destination IP address and port for an output operation. That is, we do not use sendto but use write or send instead.

2. We do not use recvfrom but read or recv instead.

slide17

3. Asynchronous errors are returned to the process for a connected UDP socket.

peer

application

}

Stores peer IP address

and port#from connect

UDP

UDP

???

UDP datagram

UDP datagram from

some other

IP address and/or port#

UDP datagram

slide18

Datagrams arriving from any other IP address or port are not

passed to the connected socket because either the source

IP address or source UDP port does not match the protocol

address to which the socket is connected.

DNS

client

DNS

client

DNS

server

DNS

client

cannot connect

connect OK

cannot connect

cannot connect

?

(configured to use

one server)

(configured to use

two server)

8 12 dg cli function revisited

8.12 dg_cli Function (Revisited)

#include “unp.h”

void dg_cli(FILE *fp, int sockfd, const SA *pservaddr, soklen_t servlen)

{

int n;

char sendline[MAXLINE], recvline[MAXLINE+1];

Connect(sockfd, (SA *) pservaddr, servlen);

while(Fgets(sendline, MAXLINE, fp) != NULL) {

sendto(sockfd, sendline, strlen(sendline), 0, pservaddr, servlen);

n = Recvfrom(sockfd, recvline, MAXLINE, 0, NULL, NULL);

recvline[n] = 0; /* null terminate */

Fputs(recvline,stdout);

}

}

8 13 lack of flow control with udp

8.13 Lack of Flow Control with UDP

#include “unp.h”

#define NDG 2000

#define DGLEN 1400

void dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t, servlen)

{

int i;

char sendline[MAXLINE];

for(I = 0; I< NDG ; I++) {

Sendto(sockfd, sendline, DGLEN, 0, pservaddr, servlen);

}

}

dg_cli function that writes a fixed number of datagram to server

slide21

#include “unp.h”

static void recvfrom_int(int);

static int count;

void dg_echo(int sockfd, SA *pcliaddr, socklen_t clilen)

{

socklen_t len;

char mesg[MAXLINE];

Signal(SIGHT, recvfrom_int);

for( ; ; ) {

len=clilen;

Recvfrom(sockfd, mesg, MAXLINE, 0, pcliaddr, &len);

count++;

}

}

static void recvfrom_int(int signo)

{

printf(“\nreceived %d datagram\n”, count);

exit(0);

}

dg_echo function that counts received datagram

slide22

The interface’s buffers were full or they could have been discarded by the sending host.

  • The counter “dropped due to full socket buffers” indicates how many datagram were received by UDP but were discarded because the receiving socket’s receive queue was full
  • The number of datagrams received b the server in this example is nondeterministic. It depends on many factors, such as the network load, the processing load on the client host, and the processing load in the server host.
  • Solution

fast server, slow client.

Increase the size of socket receive buffer.

8 14 determining outgoing interface with udp

8.14 Determining Outgoing Interface with UDP

This local address is chosen by searching the routing table for the destination IP address, and then using the primary IP address for the resulting interface.

N= 240 * 1024;

Setsockopt(sockfd, sol_SOCKET, so_RECVBUF, &n, sizeof(n));

Increases the size of the socket receive queue

slide24

Connect(sockfd,(SA *) &servaddr, sizeof(servaddr));

len = sizeof(cliaddr);

Getsockname(sockfd, (SA *) &cliaddr, &len);

printf(“local address &s\n”,Soxk_ntop((SA *) &cliaddr, len);

exit(0);

Use connect to determine outgoing interface.

This local IP address is chosen by searching the routing table

for the destination IP address, and then using the primary IP

address for the resulting

8 15 tcp and udp echo server using select

8.15 TCP and UDP Echo Server Using select

#include “unp.h”

int main(int argc, char **argv)

{

int listenfd, connfd, udpfd, nready, maxfd1;

char mesg[MAXLINE];

pid_t childpid;

fd_set rset;

ssize_t n;

socklen_t len;

const int on = 1;

struct sockaddr_in cliaddr, servaddr;

void sig_chld(int);

slide26

/* Create listening TCP socket */

listenfd = Socket(AF_INET,SOCK_STREAM, 0);

bzero(&seraddr, sizeof(servaddr));

servaddr.sin_family = AF_INET;

servaddr.sin_addr.s_addr = htol(INADDR_ANY);

servaddr.sin_port = htos(SERV_PORT);

Setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));

Bind(listenfd, (SA *)&servaddr, sizeof(servaddr));

Listenfd, LISTENQ);

/* Create UDP socket */

udpfd = Socket(AF_INET, SOCK_DGRAM, 0);

bzero(&seraddr, sizeof(servaddr));

servaddr.sin_family = AF_INET;

servaddr.sin_addr.s_addr = htol(INADDR_ANY);

servaddr.sin_port = htos(SERV_PORT);

Bind(udpfd, (SA *) &servaddr, sizeof(servaddr));

slide27

Signal(SIGCHLD, sig_chld); /* must call waitpd( )*/

FD_ZERO(&rset);

maxfdp1=max(listenfd, udpfd)+1;

for( ; ; ) {

FD_SET(listenfd, &rset);

FD_SET(udpfd, &rset);

if((nready = selext[,axfdp1, &rset, NULL, NULL,NULL) < 0) {

if(errno == EINTR)

continue;

else

err_sys(“select error”);

}

if(FD_ISSET(listenfd,&rset)) {

len = sizeof(cliaddr);

connfd = Accept(listenfd, (SA *) &cliaddr, &len);

if((childpid = fork( )) == 0) { /* child process */

Close(listenfd); /* Close listening socket */

str_echo(connfd); /* process the request */

exit(0);

}

Close(connfd);

}

slide28

if(FD_ISSET(udpfd, &rset)) {

len = sizeof(cliaddr);

n = Recvfro,(udp, mesg, MAXLINE, 0, (SA *) &cliaddr, &len);

Sendto(udpfd, ,esg, n, 0, (SA *) &cliaddr, len);

}

} /* for */

} /* main */