C# Aws Lambda Upload File to S3

At that place are two major transport layer protocols to communicate between hosts: TCP and UDP. Creating TCP Server/Client was discussed in a previous post.

Prerequisite: Creating TCP Server/Client

Theory
In UDP, the client does not form a connexion with the server like in TCP and instead just sends a datagram. Similarly, the server need not accept a connection and only waits for datagrams to arrive. Datagrams upon arrival comprise the accost of the sender which the server uses to send data to the correct client.

The entire process can be broken down into the following steps :

UDP Server :

1. Create a UDP socket.
2. Demark the socket to the server address.
3. Wait until the datagram packet arrives from the client.
4. Process the datagram packet and ship a reply to the customer.
5. Go back to Step 3.

UDP Customer :

1. Create a UDP socket.
2. Send a message to the server.
3. Expect until response from the server is received.
4. Process reply and go dorsum to footstep 2, if necessary.
5. Close socket descriptor and exit.

Necessary Functions :

int socket(int domain, int type, int protocol) Creates an unbound socket in the specified domain. Returns socket file descriptor.

Arguments :
domain – Specifies the communication
domain ( AF_INET for IPv4/ AF_INET6 for IPv6 )
type – Type of socket to be created
( SOCK_STREAM for TCP / SOCK_DGRAM for UDP )
protocol – Protocol to be used by the socket.
0 means use default protocol for the address family.

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen) Assigns address to the unbound socket.

Arguments :
sockfd – File descriptor of a socket to exist bonded
addr – Structure in which address to be bound to is specified
addrlen – Size of addr structure

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,                const struct sockaddr *dest_addr, socklen_t addrlen) Ship a bulletin on the socket

Arguments :
sockfd – File descriptor of the socket
buf – Application buffer containing the data to be sent
len – Size of buf application buffer
flags – Bitwise OR of flags to alter socket behavior
dest_addr – Structure containing the address of the destination
addrlen – Size of dest_addr structure

ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,                  struct sockaddr *src_addr, socklen_t *addrlen) Receive a message from the socket.

Arguments :
sockfd – File descriptor of the socket
buf – Application buffer in which to receive data
len – Size of buf application buffer
flags – Bitwise OR of flags to modify socket beliefs
src_addr – Structure containing source address is returned
addrlen – Variable in which size of src_addr construction is returned

int close(int fd) Close a file descriptor

Arguments:

 fd – File descriptor

In the below code, the exchange of one hello bulletin betwixt server and client is shown to demonstrate the model.

Filename: UDPServer.c

C

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <string.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <arpa/inet.h>

#include <netinet/in.h>

#define PORT     8080

#ascertain MAXLINE 1024

int main() {

int sockfd;

char buffer[MAXLINE];

char *hello = "Hello from server" ;

struct sockaddr_in servaddr, cliaddr;

if ( (sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0 ) {

perror ( "socket creation failed" );

leave (EXIT_FAILURE);

}

memset (&servaddr, 0, sizeof (servaddr));

memset (&cliaddr, 0, sizeof (cliaddr));

servaddr.sin_family    = AF_INET;

servaddr.sin_addr.s_addr = INADDR_ANY;

servaddr.sin_port = htons(PORT);

if ( bind(sockfd, ( const struct sockaddr *)&servaddr,

sizeof (servaddr)) < 0 )

{

perror ( "bind failed" );

get out (EXIT_FAILURE);

}

int len, n;

len = sizeof (cliaddr);

northward = recvfrom(sockfd, ( char *)buffer, MAXLINE,

MSG_WAITALL, ( struct sockaddr *) &cliaddr,

&len);

buffer[due north] = '\0' ;

printf ( "Client : %s\n" , buffer);

sendto(sockfd, ( const char *)hello, strlen (hello),

MSG_CONFIRM, ( const struct sockaddr *) &cliaddr,

len);

printf ( "Hello message sent.\northward" );

return 0;

}

Filename: UDPClient.c

C

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <cord.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <arpa/inet.h>

#include <netinet/in.h>

#define PORT     8080

#define MAXLINE 1024

int main() {

int sockfd;

char buffer[MAXLINE];

char *hello = "Howdy from client" ;

struct sockaddr_in     servaddr;

if ( (sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0 ) {

perror ( "socket creation failed" );

get out (EXIT_FAILURE);

}

memset (&servaddr, 0, sizeof (servaddr));

servaddr.sin_family = AF_INET;

servaddr.sin_port = htons(PORT);

servaddr.sin_addr.s_addr = INADDR_ANY;

int n, len;

sendto(sockfd, ( const char *)howdy, strlen (hi),

MSG_CONFIRM, ( const struct sockaddr *) &servaddr,

sizeof (servaddr));

printf ( "Hello bulletin sent.\n" );

n = recvfrom(sockfd, ( char *)buffer, MAXLINE,

MSG_WAITALL, ( struct sockaddr *) &servaddr,

&len);

buffer[n] = '\0' ;

printf ( "Server : %southward\north" , buffer);

close(sockfd);

render 0;

}

Output :

$ ./server Client : Hi from client Hello bulletin sent.

$ ./client How-do-you-do message sent. Server : Hullo from server

wallacehoatherand.blogspot.com

Source: https://www.geeksforgeeks.org/udp-server-client-implementation-c/

Share this post