Algorithms_in_C 1.0.0
Set of algorithms implemented in C.
Loading...
Searching...
No Matches
Macros | Functions
tcp_half_duplex_server.c File Reference

Server-side implementation of TCP Half Duplex Communication More...

#include <netdb.h>
#include <netinet/in.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
Include dependency graph for tcp_half_duplex_server.c:

Macros

#define PORT   8100
 For structures returned by the network database library - formatted internet addresses and port numbers For in_addr and sockaddr_in structures. More...
 

Functions

void error ()
 Utility function used to print an error message to stderr. More...
 
int main ()
 Main function. More...
 

Detailed Description

Server-side implementation of TCP Half Duplex Communication

Author
NVombat
See also
tcp_half_duplex_server.c

The algorithm is based on the simple TCP client and server model. However, instead of the server only sending and the client only receiving data, The server and client can both send data but only one at a time. This is implemented by using a particular ordering of the send() and recv() functions. When one of the clients or servers is sending, the other can only receive and vice-versa. In this way, the Half Duplex Form of communication can be represented using the TCP server-client model & socket programming

Macro Definition Documentation

◆ PORT

#define PORT   8100

For structures returned by the network database library - formatted internet addresses and port numbers For in_addr and sockaddr_in structures.

For specific bit size values of variables Variable types, several macros, and various functions for performing input and output Variable types, several macros, and various functions for performing general functions Various functions for manipulating arrays of characters For macro definitions related to the creation of sockets For definitions to allow for the porting of BSD programs For miscellaneous symbolic constants and types, and miscellaneous functions

Function Documentation

◆ error()

void error ( )

Utility function used to print an error message to stderr.

It prints str and an implementation-defined error message corresponding to the global variable errno.

Returns
void
37{
38 perror("Socket Creation Failed");
39 exit(EXIT_FAILURE);
40}

◆ main()

int main ( void  )

Main function.

Returns
0 on exit

Variable Declarations

< socket descriptors - Like file handles but for sockets

< character arrays to read and store string data for communication

< asic structures for all syscalls and functions that deal with internet addresses. Structures for handling internet addresses

The TCP socket is created using the socket function

AF_INET (Family) - it is an address family that is used to designate the type of addresses that your socket can communicate with

SOCK_STREAM (Type) - Indicates TCP Connection - A stream socket provides for the bidirectional, reliable, sequenced, and unduplicated flow of data without record boundaries. Aside from the bidirectionality of data flow, a pair of connected stream sockets provides an interface nearly identical to pipes

0 (Protocol) - Specifies a particular protocol to be used with the socket. Specifying a protocol of 0 causes socket() to use an unspecified default protocol appropriate for the requested socket type

< Error if the socket descriptor has a value lower than 0 - socket wasnt created

Server Address Information

The bzero() function erases the data in the n bytes of the memory starting at the location pointed to, by writing zeros (bytes containing '\0') to that area

We bind the server_addr to the internet address and port number thus giving our socket an identity with an address and port where it can listen for connections

htons - The htons() function translates a short integer from host byte order to network byte order

htonl - The htonl() function translates a long integer from host byte order to network byte order

These functions are necessary so that the binding of address and port takes place with data in the correct format

Domain/Family to be used

Port to be used

This binds the socket descriptor to the server thus enabling the server to listen for connections and communicate with other clients

If binding is unsuccessful

This is to listen for clients or connections made to the server

The limit is currently at 5 but can be increased to listen for more connections

It listens to connections through the socket descriptor

When a connection is found, a socket is created and connection is accepted and established through the socket descriptor

Communication between client and server

The bzero() function erases the data in the n bytes of the memory starting at the location pointed to, by writing zeros (bytes containing '\0') to that area. The variables are emptied and then ready for use

First the SERVER is prompted to type a message which is read from stdin and then sent over the connection that was established - the socket

  • to be received by the client (send())

The SERVER then waits for the client to reply. It then receives the reply in the string variable and displays it (recv())

The server and client can communicate till one of them exits the connection

Since the exchange of information between the server and client take place one at a time this represents HALF DUPLEX COMMUNICATION

Send message

Receive Message

Close socket

47{
48 /** Variable Declarations */
49 uint32_t sockfd,
50 conn; ///< socket descriptors - Like file handles but for sockets
51 char server_msg[10000],
52 client_msg[10000]; ///< character arrays to read and store string data
53 /// for communication
54 struct sockaddr_in server_addr,
55 client_addr; ///< asic structures for all syscalls and functions that
56 /// deal with internet addresses. Structures for handling
57 /// internet addresses
58
59 /**
60 * The TCP socket is created using the socket function
61 *
62 * AF_INET (Family) - it is an address family that is used to designate the
63 * type of addresses that your socket can communicate with
64 *
65 * SOCK_STREAM (Type) - Indicates TCP Connection - A stream socket provides
66 * for the bidirectional, reliable, sequenced, and unduplicated flow of data
67 * without record boundaries. Aside from the bidirectionality of data flow,
68 * a pair of connected stream sockets provides an interface nearly identical
69 * to pipes
70 *
71 * 0 (Protocol) - Specifies a particular protocol to be used with the
72 * socket. Specifying a protocol of 0 causes socket() to use an unspecified
73 * default protocol appropriate for the requested socket type
74 */
75 if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
76 {
77 error(); ///< Error if the socket descriptor has a value lower than 0 -
78 /// socket wasnt created
79 }
80
81 /**
82 * Server Address Information
83 *
84 * The bzero() function erases the data in the n bytes of the memory
85 * starting at the location pointed to, by writing zeros (bytes
86 * containing '\0') to that area
87 *
88 * We bind the server_addr to the internet address and port number thus
89 * giving our socket an identity with an address and port where it can
90 * listen for connections
91 *
92 * htons - The htons() function translates a short integer from host byte
93 * order to network byte order
94 *
95 * htonl - The htonl() function translates a long integer from host byte
96 * order to network byte order
97 *
98 * These functions are necessary so that the binding of address and port
99 * takes place with data in the correct format
100 */
101 bzero(&server_addr, sizeof(server_addr));
102 server_addr.sin_family = AF_INET; /// Domain/Family to be used
103 server_addr.sin_port = htons(PORT); /// Port to be used
104 server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
105
106 printf("Server is running...\n");
107
108 /**
109 * This binds the socket descriptor to the server thus enabling the server
110 * to listen for connections and communicate with other clients
111 */
112 if (bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0)
113 {
114 error(); /// If binding is unsuccessful
115 }
116
117 /**
118 * This is to listen for clients or connections made to the server
119 *
120 * The limit is currently at 5 but can be increased to listen for
121 * more connections
122 *
123 * It listens to connections through the socket descriptor
124 */
125 listen(sockfd, 5);
126
127 printf("Server is listening...\n");
128
129 /**
130 * When a connection is found, a socket is created and connection is
131 * accepted and established through the socket descriptor
132 */
133 conn = accept(sockfd, (struct sockaddr *)NULL, NULL);
134
135 printf("Server is connected...\n");
136
137 /**
138 * Communication between client and server
139 *
140 * The bzero() function erases the data in the n bytes of the memory
141 * starting at the location pointed to, by writing zeros (bytes
142 * containing '\0') to that area. The variables are emptied and then
143 * ready for use
144 *
145 * First the SERVER is prompted to type a message which is read from
146 * stdin and then sent over the connection that was established - the socket
147 * - to be received by the client (send())
148 *
149 * The SERVER then waits for the client to reply. It then receives the reply
150 * in the string variable and displays it (recv())
151 *
152 * The server and client can communicate till one of them exits the
153 * connection
154 *
155 * Since the exchange of information between the server and client take
156 * place one at a time this represents HALF DUPLEX COMMUNICATION
157 */
158 while (1)
159 {
160 bzero(&server_msg, sizeof(server_msg));
161 bzero(&client_msg, sizeof(client_msg));
162
163 /// Send message
164 printf("\nEnter message here: ");
165 fgets(server_msg, 10000, stdin);
166 send(conn, server_msg, strlen(server_msg) + 1, 0);
167
168 /// Receive Message
169 recv(conn, client_msg, sizeof(client_msg), 0);
170 printf("\nClient Message: %s\n", client_msg);
171 }
172
173 /// Close socket
174 close(sockfd);
175 printf("Server is offline...\n");
176 return 0;
177}
PORT
#define PORT
For structures returned by the network database library - formatted internet addresses and port numbe...
Definition: tcp_half_duplex_server.c:28
error
void error()
Utility function used to print an error message to stderr.
Definition: tcp_half_duplex_server.c:36
Here is the call graph for this function: