int main(int argc, char** argv)
{
int port = 0;
int s_socket = 0, c_socket = 0;
int pid = 0;
if(argc < 2) return -1;
port = atoi(argv[1]);
struct sockaddr_in server_in, client_in;
int socket_buf = 1024 * 1024;
if((s_socket = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
printf("create server socket error\n");
return -1;
}
memset(&server_in, 0, sizeof(struct sockaddr_in));
memset(&client_in, 0, sizeof(struct sockaddr_in));
server_in.sin_family = AF_INET;
server_in.sin_addr.s_addr = htonl(INADDR_ANY);
server_in.sin_port = htons(port);
setsockopt(s_socket, SOL_SOCKET, SO_RCVBUF, (char *)&socket_buf, sizeof(int));
if(bind(s_socket, (struct sockaddr *)&server_in, sizeof(struct sockaddr_in)) < 0)
{
printf("server bind port: %d error\n", port);
return -1;
}
if(listen(s_socket, 128) < 0)
{
printf("listen socket error\n");
return -1;
}
printf("server listen port:%d\n", port);
while(1)
{
int addr_len = sizeof(struct sockaddr);
c_socket = accept(s_socket, (struct sockaddr *)&client_in, &addr_len);
if(c_socket <= 0) continue;
printf(" accept client\n");
pid = fork();
if( pid == 0 )
{
close(s_socket);
process_conn_server(c_socket);
}
else
close(c_socket);
sleep(1);
}
}
int main(int argc, char *argv[])
{
int ss,sc; /*ss为服务器的socket描述符，sc为客户端的socket描述符*/
struct sockaddr_in server_addr; /*服务器地址结构*/
struct sockaddr_in client_addr; /*客户端地址结构*/
int err; /*返回值*/
pid_t pid; /*分叉的进行ID*/
/*建立一个流式套接字*/
ss = socket(AF_INET, SOCK_STREAM, 0);
if(ss < 0){ /*出错*/
printf("socket error\n");
return -1;
}
/*设置服务器地址*/
bzero(&server_addr, sizeof(server_addr)); /*清零*/
server_addr.sin_family = AF_INET; /*协议族*/
server_addr.sin_addr.s_addr = htonl(INADDR_ANY); /*本地地址*/
server_addr.sin_port = htons(PORT); /*服务器端口*/
/*绑定地址结构到套接字描述符*/
err = bind(ss, (struct sockaddr*)&server_addr, sizeof(server_addr));
if(err < 0){/*出错*/
printf("bind error\n");
return -1;
}
/*设置侦听*/
err = listen(ss, BACKLOG);
if(err < 0){ /*出错*/
printf("listen error\n");
return -1;
}
/*主循环过程*/
for(;;) {
socklen_t addrlen = sizeof(struct sockaddr);
sc = accept(ss, (struct sockaddr*)&client_addr, &addrlen);
/*接收客户端连接*/
if(sc < 0){ /*出错*/
continue; /*结束本次循环*/
}
/*建立一个新的进程处理到来的连接*/
pid = fork(); /*分叉进程*/
if( pid == 0 ){ /*子进程中*/
process_conn_server(sc); /*处理连接*/
close(ss); /*在子进程中关闭服务器的侦听*/
}else{
close(sc); /*在父进程中关闭客户端的连接*/
}
}
}
int main(int argc, char *argv[])
{
int server_socket, client_socket;
struct sockaddr_in server_addr;
struct sockaddr_in client_addr;
int err;
// Create a socket
server_socket = socket(AF_INET, SOCK_STREAM, 0);
if (server_socket < 0) {
printf("socket error\n");
return -1;
}
// build address data structure
bzero(&server_addr, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
server_addr.sin_port = htons(SERVER_PORT);
// passive open
err = bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr));
if (err < 0) {
printf("bind error\n");
return -1;
}
err = listen(server_socket, BACKLOG);
if (err < 0) {
printf("listen error\n");
return -1;
}
// waiting for connection
while(1) {
socklen_t addrlen = sizeof(struct sockaddr);
client_socket = accept(server_socket, (struct sockaddr*)&client_addr, &addrlen);
if (client_socket < 0) {
continue;
}
pid_t pid = fork();
if (pid == 0) {
process_conn_server(client_socket);
close(server_socket);
} else {
close(client_socket);
}
}
}
int main(int argc,char *argv[])
{
struct sockaddr_in server_addr; //存储服务器端socket地址结构
struct sockaddr_in client_addr; //存储客户端socket地址结构
int err; //返回值
pid_t pid; //分叉进行的ID
ss = socket(AF_INET,SOCK_STREAM,0); //建立一个序列化的，可靠的，双向连接的的字节流
if(ss<0)
{
printf("server : server socket create error\n");
return -1;
}
//初始化地址结构
memset(&server_addr,0,sizeof(server_addr));
server_addr.sin_family = AF_INET; //协议族
server_addr.sin_addr.s_addr = htonl(INADDR_ANY); //本地地址
server_addr.sin_port = htons(Network_Port);
err = bind(ss,(struct sockaddr *)&server_addr,sizeof(sockaddr));
if(err<0)
{
printf("server : bind error\n");
return -1;
}
err = listen(ss,Network_Backlog); //设置监听的队列大小
if(err < 0)
{
printf("server : listen error\n");
return -1;
}
printf("server : I am ready.\n");
// 为了方便处理，使用两个进程分别管理两个处理：
// 1，服务器监听新的连接请求;2,已建立连接的C/S实现通信。
for(;;)
{
socklen_t addrlen = sizeof(client_addr);
//accept返回客户端套接字描述符
sc = accept(ss,(struct sockaddr *)&client_addr,&addrlen); //注，此处为了获取返回值使用 指针做参数
if(sc < 0) //出错
{
continue; //结束此次循环
}
else
{
printf("server : new client connected.\n");
}
//创建一个子线程，用于与客户端通信
pid = fork();
if(pid == 0) //子进程，与客户端通信
{
close(ss);
process_conn_server(sc);
}
else
{
close(sc);
}
}
}
int main()
{
int ss,sc;
struct sockaddr_in server_sock;
struct sockaddr_in client_sock;
pid_t pid;
int err;
ss = socket(AF_INET,SOCK_STREAM,0);
if(ss < 0)
{
printf("sock build error");
return 1;
}
printf("lisock:%d\n",ss);
bzero(&server_sock,sizeof(server_sock));
server_sock.sin_family = AF_INET;
server_sock.sin_addr.s_addr = htonl(INADDR_ANY);
server_sock.sin_port = htons(_PROT_);
err = bind(ss,(struct sockaddr *)&server_sock,sizeof(server_sock));
if(bind < 0)
{
printf("bind error");
return 2;
}
err = listen(ss,_BACKLOG_);
if(err < 0)
{
printf("listen is error");
return 3;
}
while(1)
{
socklen_t len = sizeof(struct sockaddr);
sc = accept(ss,(struct sockaddr *)&client_sock,&len);
printf("sock:%d\n\n\n\n",sc);
if(sc < 0)
{
continue;
}
pid = fork();
if(pid == 0)
{
process_conn_server(sc);
close(ss);
}
else
{
close(sc);
}
}
return 0;
}
