Linux Sockets Правильный синтаксис Консольное приложение Gcc компилируется со списком неопределенных ошибок, необъяснимы ⇐ Linux

[Anonymous]

Код: Выделить всё

#include 
#include 
#include 
#include 
#include 
#include 
#include

#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 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#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 

Подробнее здесь: [url]https://stackoverflow.com/questions/79834273/linux-sockets-correct-syntax-gcc-console-app-compiles-with-list-of-undefined-err[/url]