Linux Sockets Correct Syntax Gcc Console App compiles with list of undefined errors unexplained? [closed]

#include <stdio.h>
    #include <string.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <sys/types.h>
    #include <netdb.h>
    #include <fcntl.h>
    #include <poll.h>
    
    
    #define _GNU_SOURCE
    
    
    #define http 80
    
    extern int sockvrsn, socktyp, sockprtcl;
    
    extern int clisocket;
    
    extern socklen_t clisockaddrinfsze;
    
    extern const struct sockaddr *clisockaddrinf;
    
    int cliprogram(int cliprogramend)
    {
    
    int clisockmde = AI_PASSIVE|AI_ADDRCONFIG|AI_CANONNAME;
    
    
    char *cliaddrnfoiphost = NULL;
    
    const struct addrinfo *cliaddrnfoinfr = NULL;
    
    struct addrinfo cliaddrnfo{
                  cliaddrnfo.ai_flags = clisockmde;
                  cliaddrnfo.ai_family = sockvrsn;
                  cliaddrnfo.ai_socktype = socktyp;
                  cliaddrnfo.ai_protocol = sockprtcl;
                  cliaddrnfo.ai_addrlen = clisockaddrinfsze;
                  cliaddrnfo.ai_addr = clisockaddrinf;
                  cliaddrnfo.ai_canonname = cliaddrnfoiphost;
                  cliaddrnfo.ai_next = cliaddrnfoinfr;
                  memset(&cliaddrnfo, 0, sizeof(cliaddrnfo));
              };
    
    
    
    
    const struct addrinfo *restrict cliaddrnfoinf = cliaddrnfo;
    
    struct addrinfo ** restrict cliaddrnfoinfret = clisockaddrinfr;
    
    const char *restrict getaddrinfoclistng = "http";
    
    
              int getaddrinfoinst = getaddrinfo(NULL, getaddrinfoclistng, cliaddrnfoinf, cliaddrnfoinfret);
    {
    
    
    struct addrinfo *cliaddrnfoinfretnl = cliaddrnfoinfret;
    
    void freeaddrinfo(cliaddrnfoinfretnl);
    {
    
     int sockvrsn = AF_INET;
    
     int socktyp = SOCK_STREAM;
    
     int sockprtcl = IPPROTO_TCP;
    
           int static clisocket = socket(sockvrsn, socktyp, sockprtcl);
           {
    
          sa_family_t clisockaddrvrsn = sockvrsn;
    
          in_port_t clisockaddrport = htons(80); // http port tcp/ip //
    
          sa_family_t clisockipaddrvrsn = sockvrsn;
    
          char clisockipaddrstrng[clisockipaddrstrng+1] = NULL;
    
          int clisockipaddrstrngsze = sizeof(clisockipaddrstrng);
    
          struct sockaddr clisockipaddr{
                     clisockipaddr.sa_family = clisockipaddrvrsn;      /* Address family */
                     clisockipaddr.sa_data = clisockipaddrstrng[clisockipaddrstrng+1]
                     memset(&clisockipaddr, 0, sizeof(clisockipaddr));
                 };
    
    
    
                 const char *clisockipaddrhst2nt = htonl(clisockipaddrstrng[clisockipaddrstrng+1]);
    
                  in_addr_t clisockipaddrnt = inet_addr(clisockipaddrhst2nt);
    
                 struct in_addr clisockip{
                     clisockip.s_addr = clisockipaddrnt;
                     memset(&clisockip, 0, sizeof(clisockip));
                 }
    
    
    struct sockaddr_in clisockaddr{
               clisockaddr.sin_family = clisockaddrvrsn;    /* AF_INET */
               clisockaddr.sin_port = clisockaddrport;       /* Port number */
               clisockaddr.sin_addr.s_addr = clisockipaddrnt;
               memset(&clisockaddr, 0, sizeof(clisockaddr));
    
           };
    
    
    
    
           int clisetsockoptstng = SO_DONTROUTE|SO_KEEPALIVE|SO_LINGER|SO_OOBINLINE|SO_REUSEADDR;
    
           const void *clisetsockoptstnginf = clisetsockoptstng
    
           socklen_t clisetsockoptstnginfsze = sizeof(clisetsockoptinf);
    
           int clisetsockopt setsockopt(clisocket, sockprtcl, clisetsockopt, clisetsockoptstnginf, clisetsockoptstnginfsze);
    {
           int cligetsockoptstng = SO_DONTROUTE|SO_KEEPALIVE|SO_LINGER|SO_OOBINLINE|SO_REUSEADDR;
    
           void *restrict cligetsockoptstnginf = cligetsockoptstng;
    
           socklen_t *restrict cligetsockoptstnginfsze = sizeof(cligetsockoptstnginf)
    
           int cligetsockopt = getsockopt(clisocket, sockprtcl, cligetsockoptstng, cligetsockoptstnginf, cligetsockoptstnginfsze);
    {
    
    
           struct sockaddr *restrict clisockaddrinfr = clisockaddrinf;
    
           socklen_t *restrict clisockaddrinfrsze = sizeof(clisockaddrinfr);
    
             int cligetsockinstnme = getsockname(clisocket, clisockaddrinfr, clisockaddrinfrsze);
    {
    
    const struct sockaddr *clisockaddrinf = clisockaddr;
    
    socklen_t clisockaddrinfsze = sizeof(clisockaddrinf);
    
           int static clisockcnct = connect(clisocket, clisockaddrinf, clisockaddrinfsze);
    {
    
    
            int fcntlopt = O_NONBLOCK
    
            int fcntlmde = 1;
    
            int clifilecntrliop = fcntl(clisocket, fcntlopt, fcntlmde);
    {
    
    
            struct pollfd *clipolliopfdinf = clipolliopfd;
    
            nfds_t clipolliopfd[1] = {0};
    
            int clipolltimeout = 0;
    
                   int clipolliop = poll(clipolliopfdinf, clipolliopfd[1], clipolltimeout;
    {
                   short clipollioprd = POLLIN|POLLPRI|POLLRDHUP;
    
                   short clipolliopwr = POLLOUT|POLLPRI|POLLHUP;
    
    
    
                   struct pollfd clipolliopfd {
                                  clipolliopfd.fd = clisocket;         /* file descriptor */
                                  clipolliopfd.events = clipollioprd;     /* requested events */
                                  clipolliopfd.revents = clipolliopwr;
                                  memset(&clipolliopfd, 0, sizeof(clipolliopfd));
                              };
    
                              const void clisendbtndx[clisendbtndxsze];
    
                              size_t clisendbtndxsze = sizeof(clisendbtndx);
    
                              int clisendflgs = MSG_CONFIRM|MSG_DONTROUTE|MSG_DONTWAIT|MSG_OOB;
    
                              ssize_t clisendbt = send(clisocket, clisendbtndx[clisendbtndxsze] clisendbtndxsze, clisendflgs);
    {
    
                              void clirecvbtndx[clirecvbtndxsze];
    
                              size_t clirecvbtndxsze = sizeof(clirecvbtndx);
    
                              int clirecvflags = MSG_DONTWAIT|MSG_OOB|MSG_PEEK;
    
                              ssize_t clirecvbt = recv(clisocket, clirecvbtndx[clirecvbtndxsze], clirecvbtndxsze, clirecvflags);
    {
    
    
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    }
    
    cliprogramend = 0;
    
    return cliprogramend;
    
    
    
    
    }


#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <netdb.h>
#include <fcntl.h>
#include <poll.h>
#include <unistd.h>
#include <sys/wait.h>


#include"client-connect.c"

#define _GNU_SOURCE


#define http 80

extern int sockvrsn2, socktyp2, sockprtcl2;

extern int srvsocket;

extern socklen_t srvsockaddrinfsze;

extern const struct sockaddr *srvsockaddrinf;

int main(int argc, char *argv[])
{

const struct sockaddr *restrict gtmmenfosockaddr = srvsockaddr;

socklen_t gtmmenfosockaddrsze = sizeof(gtmmenfosockaddr);

char hostnmeip[hostnmeipsze+1] = NULL;

socklen_t hostnmeipsze = sizeof(hostnmeip);

char servportip[servportipsze+1] = NULL;

socklen_t servportipsze = sizeof(servportip);

int servdmnapiflgs = NI_NUMERICHOST|NI_NUMERICSERV;

int servdmnapi = getnameinfo(gtmmenfosockaddr, gtmmenfosockaddrsze, hostnmeip[hostnmeipsze+1], hostnmeipsze, servportip[servportipsze+1], servportipsze, int flags);
{
const char *restrict hostnmeipstrng = hostnmeip[hostnmeipsze+1];

const char *restrict servportipstrng = servportip[servportipsze+1];


int srvdmnservproxyip = printf("proxy-server-name %s : %s proxy-server-port\n", string1, string2);







    int srvsockmde = AI_NUMERICHOST|AI_NUMERICSERV|AI_ADDRCONFIG|AI_CANONNAME;



    char *srvaddrnfoiphost = NULL;

    const struct addrinfo *srvaddrnfoinfr = NULL;

    struct addrinfo srvaddrnfo{
                  srvaddrnfo.ai_flags = srvsockmde;
                  srvaddrnfo.ai_family = sockvrsn2;
                  srvaddrnfo.ai_socktype = socktyp2;
                  srcaddrnfo.ai_protocol = sockprtcl2;
                  srvaddrnfo.ai_addrlen = srvsockaddrinfsze;
                  srvaddrnfo.ai_addr = srvsockaddrinf;
                  srvaddrnfo.ai_canonname = srvaddrnfoiphost;
                  srvaddrnfo.ai_next = srvaddrnfoinfr;
                  memset(&srvaddrnfo, 0, sizeof(srvaddrnfo));
              };



              const struct addrinfo *restrict srvaddrnfoinf2 = srvaddrnfo;

              struct addrinfo ** restrict srvaddrnfoinfret = srvsockaddrinfr;

              const char *restrict getaddrinfoclistng2 = "http";


                        int getaddrinfoinst2 = getaddrinfo(NULL, getaddrinfoclistng2, srvaddrnfoinf, srvaddrnfoinfret);
{


struct addrinfo *srvaddrnfoinfretnl = srvaddrnfoinfret;

void freeaddrinfo(srvaddrnfoinfretnl);
{

    int sockvrsn2 = AF_INET;

    int socktyp2 = SOCK_STREAM;

    int sockprtcl2 = IPPROTO_TCP;

    int static srvsocket = socket(sockvrsn2, socktyp2, sockprtcl2);
{



    sa_family_t srvsockaddrvrsn = sockvrsn2;

    in_port_t srvsockaddrport = htons(80); // http port tcp/ip //

    sa_family_t srvsockipaddrvrsn = sockvrsn2;

    char srvsockipaddrstrng[srvsockipaddrstrng+1] = NULL;

    int srvsockipaddrstrngsze = sizeof(srvsockipaddrstrng);

    struct sockaddr srvsockipaddr{
               srvsockipaddr.sa_family = srvsockipaddrvrsn;      /* Address family */
               srvsockipaddr.sa_data = srvsockipaddrstrng[srvsockipaddrstrng+1]
               memset(&srvsockipaddr, 0, sizeof(srvsockipaddr));
           };


           const char *srvsockipaddrhst2nt = htonl(srvsockipaddrstrng[srvsockipaddrstrng+1]);

           in_addr_t srvsockipaddrnt = inet_addr(srvsockipaddrhst2nt);

           struct in_addr srvsockip{
               srvsockip.s_addr = srvsockipaddrnt;
               memset(&srvsockip, 0, sizeof(srvsockip));
           }


struct sockaddr_in srvsockaddr{
         srvsockaddr.sin_family = srvsockaddrvrsn;    /* AF_INET */
         srvsockaddr.sin_port = srvsockaddrport;       /* Port number */
         srvsockaddr.sin_addr.s_addr = INADDR_ANY;
         memset(&srvsockaddr, 0, sizeof(srvsockaddr));


         int srvsetsockoptstng = SO_DONTROUTE|SO_KEEPALIVE|SO_LINGER|SO_OOBINLINE|SO_ACCEPTCONN|SO_REUSEPORT;

         const void *srvsetsockoptstnginf = srvsetsockoptstng

         socklen_t srvsetsockoptstnginfsze = sizeof(srvsetsockoptinf);

         int srvsetsockopt setsockopt(srvsocket, sockprtcl2, srvsetsockopt, srvsetsockoptstnginf, srvsetsockoptstnginfsze);
  {
         int srvgetsockoptstng = SO_DONTROUTE|SO_KEEPALIVE|SO_LINGER|SO_OOBINLINE|SO_ACCEPTCONN|SO_REUSEPORT;

         void *restrict srvgetsockoptstnginf = srvgetsockoptstng;

         socklen_t *restrict srvgetsockoptstnginfsze = sizeof(srvgetsockoptstnginf)

         int srvgetsockopt = getsockopt(srvsocket, sockprtcl2, srvgetsockoptstng, srvgetsockoptstnginf, srvgetsockoptstnginfsze);
  {
          int srvpndlstnlog = SOMAXCONN;

           int static srvpndlstn = listen(servsocket, SOMAXCONN);
{

           const struct sockaddr *srvsockaddrinf = srvsockaddr;

           socklen_t srvsockaddrinfsze = sizeof(srvsockaddrinf);



           int static servapicnct = bind(srvsocket, srvsockaddrinf, srvsockaddrinfsze);
{
          struct sockaddr *_Nullable restrict accptsrvsockaddr = srvsockaddr

          socklen_t *_Nullable restrict accptsrvsockaddrlen = sizeof(accptsrvsockaddr);

           int static srvacptcnct0 = accept(servsocket, accptsrvsockaddr, accptsrvsockaddrlen);
{
           pid_t ipsappfd;

           ipsappfd = fork();

           while(ipsappfd <= 300){

               int *_Nullable isappfdwtst = 0;

               int isappfdwtopt = WNOHANG;

                      pid_t isappfdwt = waitpid(isappfd, isappfdwtst, isappfdwtopt);

                      return 0;


           }



           int fcntlopt2 = O_NONBLOCK

           int fcntlmde2 = 1;

           int srvfilecntrliop = fcntl(srvsocket, fcntlopt2, fcntlmde2);
   {


           struct pollfd *srvpolliopfdinf = srvpolliopfd;

           nfds_t srvpolliopfd[1] = {0};

           int srvpolltimeout = 0;

                  int srvpolliop = poll(srvpolliopfdinf, srvpolliopfd[1], srvpolltimeout;
   {
                  short srvpollioprd = POLLIN|POLLPRI|POLLRDHUP;

                  short srvpolliopwr = POLLOUT|POLLPRI|POLLHUP;



                  struct pollfd srvpolliopfd {
                                 srvpolliopfd.fd = srvsocket;         /* file descriptor */
                                 srvpolliopfd.events = srvpollioprd;     /* requested events */
                                 srvpolliopfd.revents = srvpolliopwr;
                                 memset(&srvpolliopfd, 0, sizeof(srvpolliopfd));
                             };

                             const void srvsendbtndx[srvsendbtndxsze];

                             size_t srvsendbtndxsze = sizeof(srvsendbtndx);

                             int srvsendflgs = MSG_CONFIRM|MSG_DONTROUTE|MSG_DONTWAIT|MSG_OOB;

                             ssize_t srvsendbt = send(srvsocket, srvsendbtndx[srvsendbtndxsze] srvsendbtndxsze, srvsendflgs);
   {

                             void srvrecvbtndx[srvrecvbtndxsze];

                             size_t srvrecvbtndxsze = sizeof(srvrecvbtndx);

                             int srvrecvflags = MSG_DONTWAIT|MSG_OOB|MSG_PEEK;

                             ssize_t srvrecvbt = recv(clisocket, clirecvbtndx[clirecvbtndxsze], clirecvbtndxsze, clirecvflags);
{



}
}
}
}
}
}
}
}
}
}
}
}
}

return 0;

}

Ive written this code correctly for experimental purposes and gcc compiler throws errors regardless of the linux api syntax rules defined concisely. Machine Compatible programs are obsolete and no longer required for most applications to work correctly. Seems programs work anymore offline or in different Cloud computing development environments and that low level programming no longer works as the assembly.

Can this compile gcc linux console app correctly? The errors the compiler produced are non revisable and highly unrecommended