PLEASE CRITIQUE MY CODE

/*Client.c
* Written by: Sir Herbert Pisswhipple
* This code sends a message of variable length to an external server using the RHP protocol
* We can also send messages using the RHMP protocol
* Currently, we are sending 'hello' as an RHP control message
* and a Message Request and ID Request using the RHMP protocol
* This code was designed to be as modular as possible given the scope of this project
*/
#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>

#define SERVER "137.112.38.47"
#define WORDS "hello"
/*This code can send an RHP message of variable length (it wasn't easy)! Try it for fun */
#define PORT 1874
#define BUFSIZE 1024
#define LENGTH 99//the maximum length of an RHP message that can be sent--this value can be adjusted if necessary

uint16_t checksum(void *msg, uint16_t size);
int main() {
char MESSAGE[LENGTH] = WORDS;//An array containing the RHP message we will be sending, we will first populate it with WORDS, which is our RHP control message 
    int clientSocket, nBytes;
    uint8_t buffer[BUFSIZE];
    struct sockaddr_in clientAddr, serverAddr;
uint8_t RHP_ver = 0x05;//Our RHP version, this is always 5
uint8_t type = 2;//Our RHP type, this starts at 2 for our control message, we change it to 8 later for RHMP
uint16_t portID = 0x01A4;//The port ID of our client, it is set to 420 (John's CM#)
uint8_t portIDH = portID >> 8;//upper byte of port ID
uint8_t portIDL = portID & 0x00FF; //lower byte of port ID
int stop;//Used to determine the index at which the message recieved from the server ends
char isstart = 0;//Since the recieved message is encapsulated by zeroes, we need this variable to determine the index where the payload begins and the header ends
char resend = 0;//This keeps track of how many times we are retransmitting our message. Originally, it is zero
unsigned int msgindex = 0;//Since we can send messages of a variable length, we need this variable to keep track of the index in MESSAGE that we are sending bytes to
char sendID = 0;//This keeps track of if we have sent our ID request via RHMP
char sendMSG = 0;//This keeps track of if we have sent our message request via RHMP
unsigned int strindex = strlen(WORDS);//Keeps track of the length of the message we are sending
uint8_t msglength = sizeof(WORDS);//Keeps track of the size of the message we are sending (size and length are not always equal!)
int len;//Used to keep track of the length of our RHP message, this is used to determine if a buffer is needed or not

START:
msgindex = 0;

if((strlen(WORDS)+1) % 2 == 0){//Check if length of string is odd
len = 8 + strlen(WORDS);
}
else{
len = 7 + strlen(WORDS);
}


unsigned char SEND[LENGTH];//We are creating a large empty array that we can populate with our RHP message

    /*Create UDP socket*/
    if ((clientSocket = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        perror("cannot create socket");
        return 0;
    }

    /* Bind to an arbitrary return address.
     * Because this is the client side, we don't care about the address 
     * since no application will initiate communication here - it will 
     * just send responses 
     * INADDR_ANY is the IP address and 0 is the port (allow OS to select port) 
     * htonl converts a long integer (e.g. address) to a network representation 
     * htons converts a short integer (e.g. port) to a network representation */
    memset((char *) &clientAddr, 0, sizeof (clientAddr));
    clientAddr.sin_family = AF_INET;
    clientAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    clientAddr.sin_port = htons(0);

    if (bind(clientSocket, (struct sockaddr *) &clientAddr, sizeof (clientAddr)) < 0) {
        perror("bind failed");
        return 0;
    }

    /* Configure settings in server address struct */
    memset((char*) &serverAddr, 0, sizeof (serverAddr));
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(PORT);
    serverAddr.sin_addr.s_addr = inet_addr(SERVER);
    memset(serverAddr.sin_zero, '\0', sizeof serverAddr.sin_zero);

/*Begin loading data into our SEND array, this will be sent to the server*/
SEND[0] = RHP_ver;
SEND[1] = type;
SEND[2] = portIDL;
SEND[3] = portIDH;
SEND[4] = msglength;
msgindex += 5;//use msgindex as a variable index so that a message of any length can be sent

for(int i = 0; i < strindex; i++){
SEND[i+5] = MESSAGE[i];//append the message into the char array to be sent
msgindex++;
}

SEND[msgindex] = '\0';//add a '0' to signify end of message

if(strlen(WORDS) % 2 == 0 && type == 2){
len += 1;
}
/*Here, we have two possible ways to send a message: with and without a buffer.
* We first check if the message length is even or odd, and then determine if
* a buffer is needed. The sendto() method exists in each branch of the 'if' statement.*/
if(type == {//Reset len if we are sending an RHMP message so that the 'if' statement works correctly
len = 0;
}
if(len % 2 != 0 || strindex % 2 != 0){
unsigned char sendAway[msgindex+3];
/*SEND is a large array of zeroes, we don't want to send the entire array to the server
so here we are only copying over the portion of SEND that contains our message*/
memcpy(sendAway, SEND, msgindex+1);
msgindex++;
SEND[msgindex] = 0x00;//add a buffer if length of message is odd
msgindex++;
uint16_t check = checksum(sendAway, sizeof(sendAway)-1);//compute checksum for message
sendAway[msgindex] = check & 0xFF;
msgindex++;
sendAway[msgindex] = check >> 8;//append checksum to end of message using msgindex

/*Send message to server*/
sendto(clientSocket, sendAway, sizeof(sendAway)+1, 0,
            (struct sockaddr *) &serverAddr, sizeof (serverAddr));
}
else{
unsigned char sendAway[msgindex+2];
/*SEND is a large array of zeroes, we don't want to send the entire array to the server
so here we are only copying over the portion of SEND that contains our message*/
memcpy(sendAway, SEND, msgindex+1);
msgindex++;
uint16_t check = checksum(sendAway, sizeof(sendAway)-1);
sendAway[msgindex] = check & 0xFF;
msgindex++;
sendAway[msgindex] = check >> 8;

/*Send message to server*/
sendto(clientSocket, sendAway, sizeof(sendAway)+1, 0,
            (struct sockaddr *) &serverAddr, sizeof (serverAddr));
}
    

    /* Receive message from server */
    nBytes = recvfrom(clientSocket, buffer, BUFSIZE, 0, NULL, NULL);

/*Printing the parameters in the message recieved from the server*/

printf("RHP message sent: %s\n", MESSAGE);
printf("Received from server: \n");
printf("RHP version: %d\n", buffer[0]);
printf("RHP type: %d\n", buffer[1]);
printf("Client PortID: %d\n", portID);
printf("Server PortID: %d%d\n", buffer[3], buffer[2]);
printf("length: %d bytes\n", buffer[4]);

/*Only display RHMP parameters if the recieved message is of type RHMP*/
if(type == {
printf("RHMP type: %d\n", buffer[5] & 0b00001111);
printf("RHMP srcPort: %x%x\n", buffer[6],(buffer[5]&0b11110000)>>4);
printf("RHMP dstPort: %d\n", portID);//if the message is being sent to the client, the dstPort must be our client portID
}

for (int i = 0; i < nBytes; i++){
if(buffer[i] == 0 && isstart == 0){
isstart = 1;
}
if(buffer [i] == 0 && isstart == 1){
stop = i - 1;//get the index of the end of the recieved message, before the checksum
}
}

/*Perform a 16-bit internet checksum on the recieved message and verify it with the checksum included in the recieved message*/
unsigned char otherbuffer[nBytes];
unsigned char checksumbuffer[2];
memcpy(otherbuffer, buffer, stop+1);//make a copy of the recieved message, excluding its checksum
for(int i = nBytes; i >= stop - 1; i--){
checksumbuffer[(nBytes-i)] = buffer[i-1];//make a second char array that contains only the recieved checksum
}
printf("Message received from server: ");
if(type == 2){
for(int i = 5; i < stop + 1; i++){
printf("%c", buffer[i]);//display the recieved message
}
}
if(type == {
if(sendID == 1){
for(int i = 9; i < stop + 1; i++){
printf("%x", buffer[i]);//display the recieved message
}
}
else{
for(int i = 9; i < stop + 1; i++){
printf("%c", buffer[i]);//display the recieved message
}
}
}
printf("\n");
uint16_t recievecheck = checksum(otherbuffer, stop+1);
uint8_t recchecklower = recievecheck & 0xFF;
uint8_t reccheckupper = recievecheck >> 8;
if(checksumbuffer[0] == reccheckupper){
if(checksumbuffer[1] == recchecklower){//check to see if the computed checksum matches the provided checksum
printf("Checksum verification complete!\n");
printf("Checksum results: %x %x\n", checksumbuffer[0], checksumbuffer[1]);
printf("\n");
}
}
else if(resend < 2){//if the checksum fails, resend up to two times
/*This code will resend failed messages up to two times, which is the maximum number of failures that have been encountered in a transmission*/
printf("Verification failed, checksum: %x %x\n", reccheckupper, recchecklower);
printf("Transmission failed, resending...\n");
printf("\n");
resend++;
goto START;
}

/*RHMP MESSAGES*/
RHP_ver = 5;
type = 8;//Our type is 8 now, since this is an RHMP message
portID = 0x0138;
portIDH = portID >> 8;//upper byte of port ID
portIDL = portID & 0x00FF; //lower byte of port ID
isstart = 0;

/*Create RHMP Message for Message Request*/
unsigned char msgReq[4];//load in our RHMP message, LSB first
msgReq[0] = 0b01000100;
msgReq[1] = 0b00011010;
msgReq[2] = 0b10100100;
msgReq[3] = 0b00000001;

msglength = sizeof(msgReq);
/*Reset our MESSAGE and SEND char arrays to all 0's to ensure nothing is kept from the previous transmission*/
memset(MESSAGE,0,sizeof(MESSAGE));
memset(SEND,0,sizeof(SEND));

for(int i = 0; i < sizeof(msgReq); i++){
MESSAGE[i] = msgReq[i];//Copy msgReq into MESSAGE
}
strindex = msglength;
if(sendMSG < 1){
sendMSG = 1;//Only send if this is our first time transmitting msgReq
goto START;
}

/*Create RHMP Message for ID Request*/
unsigned char idReq[4];//load in our RHMP message, LSB first
idReq[0] = 0b01000010;
idReq[1] = 0b00011010;
idReq[2] = 0b10100100;
idReq[3] = 0b00000001;
msglength = sizeof(idReq);
/*Reset our MESSAGE and SEND char arrays to all 0's to ensure nothing is kept from the previous transmission*/
memset(MESSAGE,0,sizeof(MESSAGE));
memset(SEND,0,sizeof(SEND));

for(int i = 0; i < sizeof(idReq); i++){
MESSAGE[i] = idReq[i];//Copy idReq into MESSAGE
}
strindex = msglength;
if(sendID < 1){
sendID = 1;//Only send if this is our first time transmitting idReq
//Technically we don't need this 'if' statement since nothing is sent after this 
//but for the sake of consistency in our code we are going to include it anyways
goto START;
}

    close(clientSocket);
    return 0;
}

/*Code for computing a 16-bit internet checksum*/
uint16_t checksum(void *msg, uint16_t size){
uint16_t *dataptr = (uint16_t*) msg;
uint32_t total_sum;

while(size > 1){
total_sum += *dataptr++;
if(total_sum >> 16){
total_sum = (total_sum >> 16) + (total_sum & 0x0000FFFF);
}
size -= 2;
}
if (size == 1){
total_sum += *(((uint8_t *) dataptr));

if(total_sum >> 16){
total_sum = (total_sum >> 16) + (total_sum & 0x0000FFFF);
}
size -= 1;
}
return (~((uint16_t) total_sum));
}

Inadequate utilization of functions and professional program structure. 0 points.