Merge branch 'master' into can_deprecated_member

Author: amoldhamale1105

CMakeLists.txt

@@ -7,4 +7,5 @@ add_subdirectory(TCP)
 add_subdirectory(UDP)
 add_subdirectory(Unix)
 add_subdirectory(CAN)
-add_subdirectory(Netlink)
+add_subdirectory(Netlink)
+add_subdirectory(Virtio)

Netlink/CMakeLists.txt

@@ -1,5 +1,12 @@
 project(Netlink_Sockets)
 
+# Find the path to make binary and strip the newline character
+# NOTE We cannot use CMAKE_MAKE_PROGRAM instead because it is set based on cmake generator used which could also be Ninja
+execute_process(COMMAND which make 
+  OUTPUT_VARIABLE MAKE_PROGRAM
+)
+string(STRIP ${MAKE_PROGRAM} MAKE_PROGRAM)
+
 set(NETLINK_KERN_MODULE kernel_client)
 set(NETLINK_MOD_FILE ${NETLINK_KERN_MODULE}.ko)
 set(NETLINK_MOD_SRC_FILES ${NETLINK_KERN_MODULE}.c)
@@ -13,9 +20,9 @@ foreach(source_file ${SRC_FILES})
 endforeach(source_file ${SRC_FILES})
 
 add_custom_command(OUTPUT ${NETLINK_MOD_FILE}
-  COMMAND ${CMAKE_MAKE_PROGRAM} all
+  COMMAND ${MAKE_PROGRAM} all
   COMMAND ${CMAKE_COMMAND} -E copy ${NETLINK_MOD_FILE} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}
-  COMMAND ${CMAKE_MAKE_PROGRAM} clean
+  COMMAND ${MAKE_PROGRAM} clean
   WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
   DEPENDS ${NETLINK_MOD_SRC_FILES}
   COMMENT "Building netlink kernel module"
@@ -24,4 +31,6 @@ add_custom_command(OUTPUT ${NETLINK_MOD_FILE}
 
 add_custom_target(${NETLINK_KERN_MODULE} ALL DEPENDS ${NETLINK_MOD_FILE})
 # Clean netlink module output from the output directory on running a clean cmake target
-set_target_properties(${NETLINK_KERN_MODULE} PROPERTIES ADDITIONAL_CLEAN_FILES ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${NETLINK_MOD_FILE})
+set_target_properties(${NETLINK_KERN_MODULE} 
+  PROPERTIES ADDITIONAL_CLEAN_FILES ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${NETLINK_MOD_FILE}
+)

README.md

@@ -1,35 +1,39 @@
 # SocketProgramming
-Sockets are a fascinating concept as communication endpoints between 2 processes running on the same host using the same filesystem or on totally different hosts and filesystem miles apart but of course connected by a network  
-When I was new to socket programming it was very confusing for me to understand the concept with the code on the internet which was either too complex, lacked annotations or didn't cover enough   
-This prodded me to create this repo with some socket programming examples in C with annotations to demonstrate how sockets work  
+Sockets are a fascinating concept as communication endpoints between 2 or more entities running on the same host using the same filesystem or on totally different hosts and filesystem miles apart but of course connected by a network  
+When I was new to socket programming, it was very difficult for me to understand various types of sockets and how they work with the resources on the internet which were scattered, lacked annotations or didn't cover enough.  
+This prodded me to create a unified repo containing some examples in C with copious annotations for different types of sockets. I also created some real world applications like a network file server/sender to demonstrate their possible applications
 
-There are primarily 2 socket domains (Internet and Unix)  
-In this project, I have laid down examples with elaborate comments for 3 most commonly used types of sockets:
+In this project, I have created examples and sample apps for following type of sockets:
 - **TCP** (Stream socket used for secure reliable connection between 2 processes running on the same or different hosts on the same network)
 - **UDP** (Datagram socket used for fast data exchange between 2 processes running on the same or different hosts on the same network)
 - **Unix** (Stream/Datagram socket residing on the same filesystem as the 2 processes using it to communicate)
+- **CAN** (Raw sockets used to transmit and receive CAN messages using a can interface created by a CAN bus controller)
+- **Netlink** (Raw sockets used mostly for kernel-userspace communication and also for interprocess communication)
+- **Virtio** (Virtio sockets used for communication between host and virtual machine using the virtio-vsock driver and vhost-vsock backend)
+
+**Note:** If you're working with SocketCAN and do not have a real CAN bus to work with, you can create a virtual CAN bus interface using can-utils package. A script `vcan-setup.sh` has been created for the same under *Misc* directory of this repo https://github.com/amoldhamale1105/CodingPlayground
 
 ## Build Instructions
-This project is setup with a hierarchical cmake structure. The top level cmake adds downstream directories which in turn have their own cmake to build the sources enclosed  
-By default it will generate binaries for all sources within this repo under the `bin` directory  
+This project is setup with a hierarchical cmake structure. The top level cmake adds downstream directories which in turn have their own cmake to build the sources enclosed. By default it will generate binaries for all sources within this repo under the `bin` directory  
+
 If you working with one particular type of socket, for instance `TCP`, comment out the `add_subdirectory()` calls which are not required. The top-level cmake in our example would look something like this:
 ```
 add_subdirectory(TCP)
 #add_subdirectory(UDP)
 #add_subdirectory(Unix)
 ```
-This will save build time and unncessary build instructions when you're not intending to execute the output binaries  
-Once the target directories are set in cmake, run `Clean Reconfigure All` or `Clean Rebuild All` in case you've loaded the project using VSCode  
-Enter the following commands at the project root if you work with the command line
+This will save you some time if you're dedicatedly working on a specific type of socket  
+
+Once the target directories are set in cmake, run the build script with or without options depending on your build configuration. Defaults for each option will appear between `{}` in the usage instruction. Print the script usage by running the following command
+```
+./build.sh -h
+```
+As an example, if you want to use the script to build for release mode with `Unix Makefiles` cmake generator, it can be executed as follows
 ```
-mkdir build
-cd build
-cmake ..
-make
+./build.sh -a -r -g "Unix Makefiles"
 ```
 On a successful build, required binaries will be generated under the `bin` directory at the root of the project
 
 ## Contribution
-This is a repository catering to new programmers and experienced developers alike who like to tinker with sockets. I'd love people to contribute by adding to this project any fun experiments they conducted using raw socket programming  
-Also, any other version of code or in a different language (for instance, python) which explains socket programming in a much better manner would be great.  
-Contribution in any way is appreciable. Send me an email ([email protected]) if you happen to face issues creating branches, issues or raising pull requests 
+This is a repository catering to new programmers and experienced developers alike who like to tinker with sockets. I'd love to see you contribute by adding to this project any fun experiments you conducted using raw socket programming. Be sure to share this with people who are new to socket programming and wish to have working examples with explanation for all types of sockets in one place.  
+Contribution in any way is welcome. Get in touch with me in case of any questions or suggestions [email protected]

Virtio/CMakeLists.txt

@@ -0,0 +1,9 @@
+project(Virtio_Sockets)
+
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin/${PROJECT_NAME})
+file(GLOB SRC_FILES *.c *.cpp)
+
+foreach(source_file ${SRC_FILES})
+    get_filename_component(BINARY_NAME ${source_file} NAME_WE)
+    add_executable(${BINARY_NAME} ${source_file})
+endforeach(source_file ${SRC_FILES})

Virtio/vsock_client.c

@@ -0,0 +1,55 @@
+#include <sys/socket.h>
+#include <stdio.h>
+#include <linux/vm_sockets.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+void error(const char *);
+
+int main(int argc, char **argv)
+{
+	struct sockaddr_vm addr;
+	char buf[256];
+
+	/* Check if required number of args are provided to the program */
+	if (argc < 2){
+		fprintf(stderr, "usage: %s <port> [cid]\n", argv[0]);
+		exit(1);
+	}
+	/* Create a virtio socket */
+	int sockfd = socket(AF_VSOCK, SOCK_STREAM, 0);
+	if (sockfd < 0)
+		error("ERROR: Failed to open socket");
+
+	memset(&addr, 0, sizeof(struct sockaddr_vm));
+	addr.svm_family = AF_VSOCK;
+	addr.svm_port = atoi(argv[1]);
+	addr.svm_cid = argc > 2 ? atoi(argv[2]) : VMADDR_CID_HOST; /* Connect to VM with specified context ID or host */
+
+	if (connect(sockfd, (const struct sockaddr *)&addr, sizeof(struct sockaddr_vm)) < 0)
+		error("ERROR: Failed to connect to the virtio server");
+
+	const char *msg = "Hey there! I'm using virtio";
+	int numBytes = send(sockfd, msg, strlen(msg), 0);
+	if (numBytes < 0)
+		error("ERROR: Failed to write to socket");
+
+	/* Clear the buffer and prepare it to receive a response from the server */
+	bzero(buf, 256);
+	numBytes = recv(sockfd, buf, 255, 0);
+	if (numBytes < 0)
+		error("ERROR: Failed to read from socket");
+	printf("%s\n", buf);
+
+	/* Clean up */
+	close(sockfd);
+
+	return 0;
+}
+
+void error(const char *msg)
+{
+	perror(msg);
+	exit(1);
+}

Virtio/vsock_server.c

@@ -0,0 +1,64 @@
+#include <sys/socket.h>
+#include <linux/vm_sockets.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+void error(const char *);
+
+int main(int argc, char **argv)
+{
+	struct sockaddr_vm addr, peer_addr;
+	char buf[256];
+
+	/* Check if required number of args are provided to the program */
+	if (argc < 2){
+		fprintf(stderr, "usage: %s <port>\n", argv[0]);
+		exit(1);
+	}
+	/* Create a virtio socket */
+	int sockfd = socket(AF_VSOCK, SOCK_STREAM, 0);
+	if (sockfd < 0)
+		error("ERROR: Failed to open socket");
+
+	memset(&addr, 0, sizeof(struct sockaddr_vm));
+	addr.svm_family = AF_VSOCK;
+	addr.svm_port = atoi(argv[1]);
+	addr.svm_cid = VMADDR_CID_ANY; /* Bind to any CID to facilitate client connection from host or nested VM */
+
+	if (bind(sockfd, (const struct sockaddr *)&addr, sizeof(struct sockaddr_vm)) < 0)
+		error("ERROR: Failed to bind with socket");
+
+	listen(sockfd, 5);
+
+	socklen_t peer_addr_size = sizeof(struct sockaddr_vm);
+	int peer_fd = accept(sockfd, (struct sockaddr *)&peer_addr, &peer_addr_size);
+	if (peer_fd < 0)
+		error("ERROR: Failed to establish connection with client");
+
+	/* Send and receive to a connected virtio client */
+	bzero(buf, 256);
+	int numBytes = recv(peer_fd, buf, 255, 0);
+	if (numBytes < 0)
+		error("ERROR: Failed to receive from client");
+
+	printf("Message from the client: %s\n", buf);
+
+	const char *response = "Server response: I got your message";
+	numBytes = send(peer_fd, response, strlen(response), 0);
+	if (numBytes < 0)
+		error("ERROR: Failed to send to client");
+
+	/* Clean up */
+	close(peer_fd);
+	close(sockfd);
+
+	return 0;
+}
+
+void error(const char *msg)
+{
+	perror(msg);
+	exit(1);
+}

build.sh

@@ -0,0 +1,60 @@
+#!/bin/bash
+
+usage() { echo "usage: $0 [-a|c {a} (all|clean)] [-r|d {d} (release|debug)] [-g <cmake-generator> {Ninja}]" 2>&1; exit 0; }
+
+BUILD_TYPE="Debug"
+GENERATOR="Ninja"
+TARGET="all"
+ACTION="Build"
+
+while getopts ":acrdg:h" arg; do
+    case "${arg}" in
+        a)
+            TARGET="all"
+            ACTION="Build"
+            ;;
+        c)
+            TARGET="clean"
+            ACTION="Clean"
+            ;;
+        r)
+            BUILD_TYPE="Release"
+            ;;
+        d)
+            BUILD_TYPE="Debug"
+            ;;
+        g)
+            GENERATOR=${OPTARG}
+            ;;
+        h|*)
+            usage
+            ;;
+    esac
+done
+shift $((OPTIND-1))
+
+if [ -z "${GENERATOR}" ]; then
+    usage
+fi
+
+if [ ${TARGET} = "all" ]; then
+    if [ -d ${PWD}/build ]; then
+        rm -rf build/{.[!.]*,*}
+    fi
+    echo "Configuring project in ${BUILD_TYPE} mode..."
+    cmake -DCMAKE_BUILD_TYPE:STRING=${BUILD_TYPE} -S . -B ${PWD}/build -G "${GENERATOR}"
+fi
+
+echo "${ACTION}ing project..."
+if [ ! -z "$(ls -A ${PWD}/build)" ]; then
+    cmake --build ${PWD}/build --config ${BUILD_TYPE} --target ${TARGET}
+fi
+
+if [ ${TARGET} = "clean" ]; then
+    if [ -d ${PWD}/build ]; then
+        rm -rf build/{.[!.]*,*}
+    fi
+    if [ -d ${PWD}/bin ]; then
+        rm -rf bin/*
+    fi
+fi