c código fuente del socket síncrono

# incluir & ltsys/types .

# incluir & ltsys/socket

# incluir & ltnetinet/IP.

# incluir & ltnetinet/in

# incluir & ltarpa/inet . & ltstdio.h & gt

# incluir & ltstdlib.h & gt

# incluir & ltstrings.h & gt

# incluir & ltunistd.h & gt

# include & ltstring.h & gt

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

{

int sockfd, new_socket

int sock_value

char buf[] = "¡Hola! ¡China! Te amo\n";

client struct sockaddr _ in _ en

server_struct sockaddr _ in

int TAMAÑO = sizeof(struct sockaddr _ in);

if (argc ! = 2){

fprintf(stderr, "¡Estos dos números!\n");

Salir(1);

}

if((sock _ valor = atoi(argv[1])<0){

fprintf(stderr, "¡Error de socket!\n");

Salir(1);

}

if((sockfd = socket(PF_INET, SOCK_STREAM, 0)) == -1){

perror("socket");

Salir(1);

}

bzero(& server_, TAMAÑO);

server_.sin_family=PF_INET

server_.sin_port =htons(sock_value);

servidor_. sin _ addr.s _ addr = INADDR _ ANY

if(bind(sockfd, (struct sockaddr *)(& server_), TAMAÑO) == -1){

perror (" enlazar ");

Salir(1);

}

if(escuchar(sockfd, 12) == -1){

error("Escucha");

Salir(1

}

printf("Esperando... \ n ");

while(1){

if((new_socket = aceptar(sockfd, (struct sockaddr *)(& client_), & ampSIZE)) = = -1){

perror("Aceptar");

Salir(1);

}

printf("Cliente La IP del terminal es %s\ n ", inet_ntoa(cliente_.

sin_addr));

printf("El socket es %d\n ",ntohs(client_.sin_port));

if(write(new_socket,buf, strlen(buf)) == -1){

error("escribir");

Salir(1);

}

int mi

char my buf[1024];

if((my = read(new_socket, mybuf, 1024)) == -1){

perror(" leer");

Salir(1);

}

mi buf[mi]= '\ 0';

printf("#++++#++++#:%s\n ",mi buf);

cerrar(nuevo _ socket);

}

Cerrar(sockfd);

Devolver 0;

}

# incluir & ltsys/types

# incluir & ltsys/socket .

# incluir & ltnetinet/IP

# incluir & ltnetinet/in .

# incluir & ltarpa/inet . h & gt；

# incluir & ltstdio.h & gt

# incluir & ltstdlib.h & gt

# include & ltstrings.h & gt

# include & ltunistd.h & gt

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

{

int sockfd

int sock _ value

char buf[1024];

char my buf[] = " Linux \ n ";

int read_count;

estructura en client_sockaddr_in

estructura en server_sockaddr_in

int TAMAÑO = sizeof(struct sockaddr _ in);

if (argc! = 3){

fprintf(stderr, "¡Estos dos números!\n ");

Salir(1);

}

if((sock_value = atoi(argv[2])<0){

fprintf(stderr, "¡Error de socket!\n ");

Salir(1) ;

}

if((sockfd = socket(PF_INET, SOCK_STREAM, 0)) == -1){

error ("socket");

Salir(1);

}

bzero(& cliente_, TAMAÑO);

bzero(& servidor_, TAMAÑO);

client_sin_home=PF_INET

client_sin_port=htons(52252);

Cliente_.

sin_adr.s_adr = INADDR_ANY

servidor_. sin_family=PF_INET

servidor_. sin_port = htons(sock_value);

server_. sin _ addr . s _ addr = inet _ addr(argv[1]);

if(connect(sockfd, (struct sockaddr *)(& server_), TAMAÑO) == -1) {

perror("Conexión");

Salir(1);

}

if((read_count = read(sockfd ,buf ,1024)) == -1){

error("leer");

Salir(1);

}

buf[read _ count]= ' \ 0 ';

printf("# - # - #:%s\n ",buf);

if(write (sockfd , mybuf, 6) == -1){

error("escribir");

Salir(1);

}

Cerrar(sockfd);

Salir(0);

Devolver 0;

}