Npc08
Upcoming SlideShare
Loading in...5
×
 

Npc08

on

  • 634 views

 

Statistics

Views

Total Views
634
Views on SlideShare
625
Embed Views
9

Actions

Likes
0
Downloads
29
Comments
0

2 Embeds 9

http://vamsinp.blogspot.in 7
http://vamsinp.blogspot.com 2

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Npc08 Npc08 Presentation Transcript

  • Chapter 8Elementary UDP Socket
  • Contentsrecvfrom and sendto FunctionUDP Echo Server( main, de_echo Function)UDP Echo Client( main, de_cli Function)Lost datagramsVerifying Received ResponseSever not RunningConnect Function with UDPLack of Flow Control with UDPDetermining Outgoing Interface with UDPTCP and UDP Echo Server Using select
  • 8.1 Introduction connectionless unreliable datagram protocol popular using DNS(the Domain Name System) NFS(the Network File System) SNMP(Simple Network Management Protocol)
  • UDP Server socket( ) bind( )UDP Client socket( ) recvfrom( ) block until datagram sendto( ) received from a client data(request) Process request recvfrom( ) data(reply) sendto( ) close( ) Socket functions for UDP client-server
  • 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 fgets sendto recvfrom stdin UDP UDP stdout client server fputs recvfrom sendto Simple echo client-server using UDPUDP echo server #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)); }
  • 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.
  • 1.This function never terminates. 2.This function provides an iterative, not a concurrent server as we had with TCP connection server fock listening fock server connectionclient child client child serverTCP TCP TCP connection connection Summary of TCP client-server with two clients.
  • client server client Socket receive buffer UDP UDPUDP datagram datagram Summary of UDP client-server with two clients.
  • 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 #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 DatagramsIf the client datagram arrives at the serverbut the server’s reply is lost, the client willagain block forever in its call to recvfrom.The only way to prevent this is to place atimeout on the recvfrom.
  • 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
  • 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.66Solaris % udpcli02 206.62.226.66 The server has not bound an IP addresshello to its socket, the kernel choose the sourcereply from 206.62.226.35.7 (ignore) address for the IP datagram. It is chosengoodbye to be the primary IP address of the outgoingreply from 206.62.226.35.7 (ignore) interface.
  • 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 notreturned for UDP sockets unless the socket hasbeen connected.
  • 8.11 connect Function with UDPThis does not result in anything like a TCPconnection: there is no three-way handshake.Instead, the kernel just records the IP address andport number of the peer.With a connect UDP socket three change:1. We can no long specify the destination IP addressand port for an output operation. That is, we do notuse sendto but use write or send instead.2. We do not use recvfrom but read or recvinstead.
  • 3. Asynchronous errors are returned to the process for a connected UDP socket. application peer ??? UDP } Stores peer IP address and port#from connect UDP UDP datagramUDP datagram fromsome otherIP address and/or port# UDP datagram
  • 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 DNS DNS DNS clien client server client t connect OK cannot connect cannot connect cannot connect(configured to use one server) (configured to use two server) ?
  • 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 #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
  • #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 datagramn”, count); exit(0);} dg_echo function that counts received datagram
  • The interface’s buffers were full or they could have beendiscarded by the sending host. The counter “dropped due to full socket buffers” indicates howmany datagram were received by UDP but were discarded becausethe receiving socket’s receive queue was full The number of datagrams received b the server in this example isnondeterministic. It depends on many factors, such as the networkload, the processing load on the client host, and the processing loadin the server host. Solution fast server, slow client. Increase the size of socket receive buffer.
  • 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
  • Connect(sockfd,(SA *) &servaddr, sizeof(servaddr)); len = sizeof(cliaddr); Getsockname(sockfd, (SA *) &cliaddr, &len); printf(“local address &sn”,Soxk_ntop((SA *) &cliaddr, len); exit(0); Use connect to determine outgoing interface.This local IP address is chosen by searching the routing tablefor the destination IP address, and then using the primary IPaddress for the resulting
  • 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);
  • /* 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));
  • 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);}
  • 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 */