• Like
Internet socket programming using tcp assignment2
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

Internet socket programming using tcp assignment2

  • 277 views
Published

 

Published in Education , Technology
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
No Downloads

Views

Total Views
277
On SlideShare
0
From Embeds
0
Number of Embeds
0

Actions

Shares
Downloads
4
Comments
0
Likes
1

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. Internet socket programming using TCP/IP The AF_INET sockets may be used by programs communicating across a TCP/IP network including the Internet. The Windows Winsock interface also provides access to this socket domain. SOCK_STREAM is a sequenced, reliable, connection-based two-way byte stream. For an AF_INET domain socket, this is provided by default by a TCP connection that is established between the two end points of the stream socket when it’s connected. Data may be passed in both directions along the socket connection. The TCP protocols include facilities to fragment and reassemble long messages and to retransmit any parts that may be lost in the network. The protocol used for communication is usually determined by the socket type and domain. There is normally no choice. The protocol parameter is used where there is a choice. 0 selects the default protocol. Socket Addresses In the AF_INET domain, the address is specified using a structure called sockaddr_in, defined in <netinet/in.h>, which contains at least these members: struct sockaddr_in { short int sin_family; /* AF_INET */ unsigned short int sin_port; /* Port number */ struct in_addr sin_addr; /* Internet address */ }; The IP address structure, in_addr, is defined as follows: struct in_addr { unsigned long int s_addr; }; The underlying protocol, Internet Protocol (IP), which only has one address family, imposes a particular way of specifying computers on a network. This is called the IP address. In IPV4, the four bytes of an IP address constitute a single 32-bit value. An AF_INET socket is fully described by its domain, IP address, and port number. From an application’s point of view, all sockets act like file descriptors and are addressed by a unique integer value. IPv6 uses a different socket domain, AF_INET6, and a different address format. There may be several services available at the server computer. A client can address a particular service on a networked machine by using an IP port. A port is identified within the system by assigning a unique 16-bit integer and externally by the combination of IP address and port number. The sockets are communication end points that must be bound to ports before communication is possible. If you want to allow the server to communicate with remote clients, you must specify a set of IP addresses that you are willing to allow. You can use the special value, INADDR_ANY, to specify that you’ll accept connections from all of the interfaces your computer may have. If you chose to, you could distinguish between different network interfaces to separate, for example, internal Local Area Network and external Wide Area Network connections. INADDR_ANY is a 32-bit integer value that you can use in the sin_addr.s_addr field. These functions convert 16-bit and 32-bit integers between native host format and the standard network ordering. Their names are abbreviations for conversions — for example, “host to network, long” (htonl) and “host to network, short” (htons). For computers where the native ordering is the same as network ordering, these represent null operations. To ensure correct byte ordering of the 16-bit port number, your server and client need to apply these functions to the port address. The change to server3.c is server_address.sin_addr.s_addr = htonl(INADDR_ANY);
  • 2. server_address.sin_port = htons(9734); You don’t need to convert the function call, inet_addr(“127.0.0.1”), because inet_addr is defined to produce a result in network order. The change to client3.c is address.sin_port = htons(9734); The server has also been changed to allow connections from any IP address by using INADDR_ANY. of the address structure. However, you have a problem to resolve first. Servers wait for connections on particular ports. Well-known services have allocated port numbers that are used by all Linux and UNIX machines. These are usually, but not always, numbers less than 1024. Examples are the printer spooler (515), rlogin (513), ftp (21), and httpd (80). The last of these is the standard port for web servers. Usually, port numbers less than 1024 are reserved for system services and may only be served by processes with super user privileges. X/Open defines a constant in netdb.h, IPPORT_RESERVED, to stand for the highest reserved port number. Naming a Socket AF_INET sockets are associated with an IP port number. #include <sys/socket.h> int bind(int socket, const struct sockaddr *address, size_t address_len); The bind system call assigns the address specified in the parameter, address, to the unnamed socket associated with the file descriptor socket. The length of the address structure is passed as address_len. The length and format of the address depend on the address family. A particular address structure pointer will need to be cast to the generic address type (struct sockaddr *) in the call to bind.On successful completion, bind returns 0. If it fails, it returns -1 and sets errno. Sample to solve Assignment2: Write a C program using TCP/IP socket to send user data from client and server will receive the data and concatenate that with user given data at server side and send it to client. Client program: #include <sys/types.h> #include <sys/socket.h> #include <stdio.h> #include <netinet/in.h> #include <arpa/inet.h> #include <unistd.h> #include <stdlib.h> int main() { int sockfd; int len; struct sockaddr_in address; int result,l; char msg[2048]; sockfd = socket(AF_INET, SOCK_STREAM, 0); address.sin_family = AF_INET; address.sin_addr.s_addr = inet_addr("127.0.0.1"); address.sin_port = 9734; len = sizeof(address); result = connect(sockfd, (struct sockaddr *)&address, len); if(result == -1) { perror("oops: client1"); exit(1); } fgets(msg,200,stdin); l=sizeof(msg); write(sockfd, &msg, l);
  • 3. read(sockfd, &msg, l); printf("char from server = %sn", msg); close(sockfd); exit(0); } Creating socket: sockfd = socket(AF_INET, SOCK_STREAM, 0); This is same as file socket only the domain has been changed to AF_INET. Socket Addresses The client program used the sockaddr_in structure from the include file <netinet/in.h> to specify an AF_INET address. It tries to connect to a server on the host with IP address 127.0.0.1. It uses a function, inet_addr, to convert the text representation of an IP address into a form suitable for socket addressing. The manual page for inet has more information on other address translation functions. struct sockaddr_in struct sockaddr_in { u_char sin_len; u_short sin_family; // Address family u_short sin_port; // Port number struct in_addr sin_addr; // Internet or IP address char sin_zero[8]; // Same size as struct sockaddr };  The sin_family field is the address family (always AF_INET for TCP and UDP).  The sin_port field is the port number, and the sin_addr field is the Internet address. The sin_zero field is reserved, and you must set it to hexadecimal zeroes.  Data type struct in_addr - this data type is used in certain contexts to contain an Internet host address. It has just one field, named s_addr, which records the host address number as an unsigned long int.  sockaddr_in is a "specialized" sockaddr.  sin_addr could be u_long.  sin_addr is 4 bytes and 8 bytes are unused.  sockaddr_in is used to specify an endpoint.  The sin_port and sin_addr must be in Network Byte Order. address.sin_family = AF_INET; This stamen define that socket address is under AF_INET domain address.sin_addr.s_addr = inet_addr("127.0.0.1"); This statement identifies the network. Host Address Data Type - Data type for a host number.  Internet host addresses are represented in some contexts as integers (type unsigned long int).  In other contexts, the integer is packaged inside a structure of type struct in_addr. It would be better if the usages were made consistent, but it is not hard to extract the integer from the structure or put the integer into a structure.  The following basic definitions for Internet addresses appear in the header file 'in.h'. struct in_addr  This data type is used in certain contexts to contain an Internet host address. It has just one field, named s_addr, which records the host address number as an unsigned long int. unsigned long int INADDR_LOOPBACK
  • 4.  You can use this macro constant to stand for the ''address of this machine'' instead of finding its actual address.  It is the Internet address '127.0.0.1', which is usually called 'localhost'. This special constant saves you the trouble of looking up the address of your own machine.  Also, the system usually implements INADDR_LOOPBACK specially, avoiding any network traffic for the case of one machine talking to itself. unsigned long int INADDR_ANY  You can use this macro constant to stand for ''any incoming address'' when binding to an address. This is the usual address to give in the sin_addr member of struct sockaddr_in when you want your server to accept Internet connections. unsigned long int INADDR_BROADCAST  This macro constant is the address you use to send a broadcast message.  Likewise, by setting address.sin_addr.s_addr to INADDR_ANY, you are telling it to automatically fill in the IP address of the machine the process is running on.  INADDR_ANY is actually zero. For 0.0.0.0, it means any IP. address.sin_port = 9734; We have select port number 9734. This is an arbitrary choice that avoids the standard services (you can’t use port numbers below 1024 because they are reserved for system use). Other port numbers are often listed, with the services provided on them, in the system file /etc/services. When you’re writing socket-based applications, always choose a port number not listed in this configuration file. Connecting socket: Connecting internet socket is same as file socket. Now you can write anything from key board and do read operation as you have done in file socket. Server program: #include <sys/types.h> #include <sys/socket.h> #include <stdio.h> #include <netinet/in.h> #include <arpa/inet.h> #include <unistd.h> #include <stdlib.h> #include<string.h> int main() { int server_sockfd, client_sockfd; int server_len,len,p; struct sockaddr_in server_address; struct sockaddr_in client_address; server_sockfd = socket(AF_INET, SOCK_STREAM, 0); server_address.sin_family = AF_INET; server_address.sin_addr.s_addr = inet_addr("127.0.0.1"); server_address.sin_port = 9734; server_len = sizeof(server_address); bind(server_sockfd, (struct sockaddr *)&server_address, server_len); listen(server_sockfd, 5); while(1) { char msg[2048],msg1[2048]; printf("server waitingn"); len = sizeof(client_address);
  • 5. client_sockfd = accept(server_sockfd,(struct sockaddr *)&client_address,&len); read(client_sockfd, &msg, sizeof(msg)); fgets(msg1,2048,stdin); strcat(msg,msg1); p=sizeof(msg); write(client_sockfd, &msg,p); close(client_sockfd); } }