Ik kwam acors deze codering wanneer surfin de net.this code werkt perfectly.but zoals ik ben nieuw bij deze socket programmering i need sm coments genoteerd op of een toelichting met betrekking tot deze broncode.
Ik heb begrip van de PRB server.ci hebben gepost het hieronder
kunt u guys help me!
cheerZ


De server.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <sys/time.h>
#define MAX_CLIENTS 64

struct sockaddr_in servaddr;
int addr_len;
struct sockaddr addr;
struct sockaddr_in *ptr;
int cl_addr_len;
struct sockaddr_in cl_addr;
char in_buf[100], out_buf[100];
char names [10][30];
char message[150];
int num_names = 0;

	typedef struct cl_info
		{
			char cl_id[30];
			int cl_status;
		}cl_info;

	cl_info clients[MAX_CLIENTS];

	int main(int argc, char **argv)
		{
			int newsockfd;
			int sockfd;
			int nbytes;
			int max_fd;
			int fd;
			short func_num;

			fd_set test_set, ready_set;



	sockfd = socket(AF_INET, SOCK_STREAM, 0); 
	servaddr.sin_family - AF_INET;
	servaddr.sin_port = 0;				 /*choose an unused port at random */
	servaddr.sin_addr.s_addr = INADDR_ANY;	 	/* auto fill with my IP address */
	bind(sockfd,(struct sockaddr*) &servaddr, sizeof(servaddr));

	addr_len = sizeof(addr);
	getsockname(sockfd, &addr, &addr_len);
	ptr = (struct sockaddr_in *)&addr;
	printf("\nServer on port# %d\n", ptr->sin_port);

	listen(sockfd, 5);
	max_fd = sockfd; 
	FD_ZERO(&test_set); /*clear the listening socket */

	FD_SET(sockfd, &test_set);

	

	while(1)
		{
			memcpy(&ready_set, &test_set, sizeof(test_set));
			select(max_fd+1, &ready_set, NULL, NULL, NULL);
			
			if(FD_ISSET(sockfd, &ready_set)) /*if listening sock has data its a call from new client */
				{
					/*create a new socket */

					cl_addr_len = sizeof(cl_addr);
					newsockfd = accept(sockfd, (struct sockaddr *)&cl_addr, &cl_addr_len);

					printf("\nA new connection has been made to socket %d\n", newsockfd);
					FD_SET(newsockfd, &test_set); /* add new socket to list */
					if(newsockfd > max_fd)
						max_fd = newsockfd; /*update max_fd with new socket file discriptor */
				} /*end if*/


			for(fd=0; fd <= max_fd; fd++) /*loop through connected socket file discriptors */
{
if((fd !=sockfd) && FD_ISSET(fd, &ready_set))/*bypass listening sock if sock has data*/
if(process_call(fd, max_fd) == 0) /*if socket is closed */
{
printf("\nThe listening socket is now closed\n");
close(newsockfd);
printf("\nClient on socket %d has left the room\n", sockfd);
FD_CLR(fd, &test_set); /*remove socket from list */
/*decrement user count */
} /*end if */
} /* end for loop */
} /*end while loop */
return 0;
} /*end main */
int add_name(int sockfd)
{
int nbytes;
short name_len;
short n_name_len;

printf("\nAdding name .....\n");
nbytes = read(sockfd, (char *)&name_len, sizeof(short));
name_len = ntohs(name_len); /*convert name_len from network to host short */
memset(clients[sockfd].cl_id, 0, 30); /*set all bytes to zero */
nbytes = read(sockfd, clients[sockfd].cl_id, name_len);
num_names ++; /*increment user count */
printf("\n%s has joined the chat room\n", clients[sockfd].cl_id);

/*need to broadcast user has joined plus user id to connected clients here */

} /*end add_name function */
int how_many(int sockfd, int max)
{
int sock;
short user_len;
char username[30];

for(sock = 4; sock <= max; sock++)
{
strcpy(username, clients[sock].cl_id);

user_len = htons(strlen(username));
write(sockfd, (char *)&user_len, sizeof(short));
write(sockfd, username, strlen(username));
send_user_list(sockfd, username);
}
} /*end how_many function */
int send_user_list(int sockfd, char *users)
{
short msg_type;
short user_len;

msg_type = htons(2);
printf("msg_type is : %u\n", msg_type);
write(sockfd, &msg_type, sizeof(short));

user_len = htons(strlen(users));
write(sockfd, (char *)&user_len, sizeof(short));
write(sockfd, users, strlen(users));
}
int find_name(int sockfd, int max)
{
char search_name[30];
int sock;
int found = 0;
short len, name_len;
char sender[30];
short sender_len;
char msg[150];
short msg_len;

memset(search_name, 0, 30); /*set all bytes to zero */
printf("\nReceiving userid......\n");
read(sockfd, (char *)&name_len, sizeof(short));
len = ntohs(name_len);
read(sockfd, search_name, len);
read(sockfd, &msg_len, sizeof(short));
msg_len = ntohs(msg_len);
read(sockfd, msg, msg_len);
msg[msg_len] = '\0';

strcpy(sender, clients[sockfd].cl_id);

for(sock = 4; sock <= max; sock++)
{
printf(" %d is held in max\n", max);
printf("\ncomparing search request for %s with %s username\n",
search_name, clients[sock].cl_id);
if(strcmp(search_name, clients[sock].cl_id) ==0)
{
printf("\nuserid found\n");
found = 1;
send_async_msg(sock, msg,sender);
}/*end if */
} /*end for loop */

if(! found)
{
printf("\nuserid not found\n");
} /*end if */
}/*end find_name function */
int process_call(int newsockfd, int max_fd)
{
int nbytes;
short func_num;

nbytes = read(newsockfd, (char *)&func_num, sizeof(short));
if(nbytes ==0)
return 0;
if (nbytes != sizeof(short))
{
perror("\nUnknown menu option!\n");
exit(1);
} /* end if */

func_num = ntohs(func_num);
switch(func_num)
{
case(1):
add_name(newsockfd);
break;
case(2):
how_many(newsockfd, max_fd);
break;
case(3):
find_name(newsockfd, max_fd);
break;
case(4):
send_global_msg(newsockfd, max_fd);
break;
case(5):
printf("\nShutting down Server...\n");
exit(0);
default:
printf("\nUnknown function number!\n");
break;
} /*end switch */
} /*end process_call function */
int send_async_msg(int sockfd, char * msg, char *sender)
{
short msg_type;
short msg_len;
short sender_len;

msg_type = htons(1);
printf("msg_type is : %u\n", msg_type);
write(sockfd, &msg_type, sizeof(short));
msg_len = htons(strlen(msg));
write(sockfd, (char *)&msg_len, sizeof(short));
write(sockfd, msg, strlen(msg));

sender_len = htons(strlen(sender));
write(sockfd, (char *)&sender_len, sizeof(short));
write(sockfd, sender, strlen(sender));
}/* end of send_async_msg function */
int send_global_msg(int sockfd, int max_fd)
{
int nbytes;
int sock;
short len;
short msg_type;
char msg[150];
char sender[30];
short sender_len;

strcpy(sender, clients[sockfd].cl_id);

msg_type = 1;
memset(in_buf, 0, sizeof(in_buf)); /*set all to zero */
nbytes = read(sockfd, &len, sizeof(short));
len = ntohs(len);
read(sockfd, msg, len);
message[len] = '\0';
for(sock = 4; sock <= max_fd; sock++)
{
send_async_msg(sock, msg, sender);
} /*end for loop */
} /* end of send_global_msg function */

Er was zo veel posten voor netwerk programmering starters

een zodanig beej's guide to n / w PRG

U kunt zoeken op het forum voor meer

zal u antwoord op mijn vraag aub dat ik heb gepost 2 uur geleden.

Bedankt.

Wat is de functie die u verwijzen naar?
is dat uit een andere draad?

Hallo,

bedankt. U gaf me al klaar antwoord over de winning van string en vervolgens afdrukken uit. Ik dacht dat niemand het zag.

Op de toekomst, zal ik wachten voor een lange tijd, voordat de vraag opnieuw. Mijn vraag was hoe om een specifieke string uit een bestand met sscanf () en dan printen maar.

Ik heb het antwoord. Maar nu vraag ik me af of het mogelijk is om meer dan een string uit meer dan een regel uit een bestand. Zeg, we hebben een bestand,

cat / proc / cpuinfo

processor: 0
vendor_id: GenuineIntel
cpu family: 15
model: 2
Model naam: Intel (R) Celeron (R) CPU 2.60GHz
stepping: 9
cpu MHz: 2591.654
cache size: 128 KB
fdiv_bug: geen
hlt_bug: geen
f00f_bug: geen
coma_bug: geen
fpu: yes
fpu_exception: ja
cpuid niveau: 2
wp: yes
flags: fpu vme de pse

En ik wil uittreksel

vendor_id: GenuineIntel
model: 2
Model naam: Intel (R) Celeron (R) CPU 2.60GHz

Ik weet dat het mogelijk is door wrting de volgende code drie keer in dit geval als we de winning van drie snaren hier.

if (NULL \u003d\u003d (fp \u003d fopen (argv [1], "rt "))){
printf ( "Cannot open% s \ n", argv [1]);
exit (1);
)
for (; fgets (buf, 255, fp)(
if (buf \u003d\u003d strstr (buf, "naam")) (
if (NULL! \u003d (p \u003d strchr (buf,':')))
printf ( "% s \ n", p + 1);
break;
)

Maar is er een manier, die ik kan schrijven van de code een keer maar kan uittreksel enkele specifieke strings en print ze uit in een keer de een na de andere.

En ook is er een manier, zodat in een C bestand ik kan openen mutiple bestanden door command line argument, de een na de andere. Zeggen, nadat ik ben klaar met printen vendor_id, model type en model naam uit cpuinfo bestand uit / proc directory, open ik de stat bestand uit de / proc directory en start winning van enkele specifieke strings en drukken ze weer. Is dat een zeer compilcated manier veel simpel. Laat het me weten hoe ik dat moet doen als u weet.

En ook, als we winnen van een string, bijvoorbeeld, cpu family: 15, 15 is een type string. Zeg, ik wil converteren string 15 tot een integer; ja, ik gebruik atoi (), maar om te printen, heb ik het volgende doen toch?

int aantal \u003d atoi (p);
printf ( "Het getal is:% d \ n", aantal);

Maar goed ik kan niet printen de integer waarde. Dus, ik denk dat ik er iets ontbreekt.

Welke hulp kan ik krijgen, zal ik zeer dankbaar.
Bedankt.