有没有用C编写的服务端SOCKET程序

[weepp]

就是本机建立服务,打开服务端口的程序.谢谢

[jim138]

友情 UP :)))
MARK,我也想要这方面的资料,不知哪位大虾支持一下..了。.

[米西米西2]

UNP(Unix Network Porgramming). Vol1 , Page 11.

[Bread_0053]

#include <iostream.h>
#include <winsock2.h>

void main()
{
WSADATA wsd;
SOCKET sListen,sClient;
struct sockaddr_in local,client;
struct hostent * host = NULL;

WSAStartup(MAKEWORD(2,2),&wsd);

sListen = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);

local.sin_addr.S_un.S_addr = htonl(INADDR_ANY);

local.sin_family = AF_INET;

local.sin_port = htons(4444);

bind(sListen,(struct sockaddr*)&local,sizeof(local));

listen(sListen,8);

int iAddrSize = sizeof(client);

sClient = accept(sListen,(struct sockaddr *)&client,&iAddrSize);

char buf[10] = "hello";
send(sClient,buf,6,0);

cout<<"send succeed!\n";
return;
}

windows 下这样可以，linux下的也差不多，不想重起机器了，呵呵。。

[dot99]

大部分socket相关的代码都是C写的
推荐<UNIX网络编程>

[lijiangshui]

stevens写的<unix网络编程>就是说这些东西的啊，里面还有代码，看看吧

[Neo_Liu]

我自己写的一个简单ＨＴＴＰ代理程序，不过用一段时间就会出问题

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
#include "public.h"
#undef DEBUG

int port=HTTP_PORT;

static int index_thread=0;

void* start_thread(void* arg);
void handle_request(int connfd);

int main(){
int sockfd,connfd;
int opt; /* socket option SO_REUSEADDR */
SockAddr_In server; /* server's address information */
SockAddr_In client; /* client's address information */
pthread_t thread;
int sin_length; /* the length of sockaddr_in */

/* create a Tcp socket */
if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1){
perror("socket() error");
exit(1);
}

/* set socket option to reuse address */
opt=SO_REUSEADDR;
setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));

/* initialize server's socket information */
bzero(&server,sizeof(server));
server.sin_family=AF_INET;
server.sin_port=htons(PROXY_PORT);
server.sin_addr.s_addr=htonl(INADDR_ANY);

/* bind server to the socket */
if(bind(sockfd,(SockAddr*)&server,sizeof(SockAddr))==-1){
perror("bind() error");
exit(1);
}

if(listen(sockfd,BACK_LOG)==-1){
perror("listen() error");
exit(1);
}

sin_length=sizeof(SockAddr_In);

printf("sockfd=%d\n",sockfd);

while(1){
/* accpet connection */
if((connfd=accept(sockfd,(SockAddr*)&client,&sin_length))==-1){
perror("accept() error");
exit(1);
}

//printf("connfd=%d\n",connfd);

/* create new thread */
if(pthread_create(&thread,NULL,start_thread,(void*)&connfd)){
perror("pthread_create() error");
exit(1);
}
//printf("threadid=%d\n",(int)thread);
}

close(sockfd);
}

void handle_request(int connfd){
int num; /* the number of receiving client's data */
int proxy_sockfd;
int proxy_connfd;
int num_select;
int port_tmp;
char recv_buf[MAX_DATA_SIZE],send_buf[MAX_DATA_SIZE];
char* url_begin;
char* url_end;
char* url;
char* url_tmp;
SockAddr_In proxy;
struct hostent* hs;
fd_set read_set;

int i;

num=recv(connfd,recv_buf,MAX_DATA_SIZE,0);
if(num==-1){
perror("recv() error");
close(connfd);
return;
}

#ifdef DEBUG
recv_buf[num]='\0';
printf("=============IP client request=================\n");
printf("%s\n",recv_buf);
printf("=============================================\n");
#endif

/* get URL of HTTP request */
url_begin=strstr(recv_buf,"Host:")+6; /* Host: www.langchao.com Connection:...... */
url_end=strchr(url_begin,CHANGE_LINE);
url=malloc(url_end-url_begin+1);
memcpy(url,url_begin,url_end-url_begin);
url[url_end-url_begin]='\0';

#ifdef DEBUG
printf("URL=%s\n",url);
#endif

/* handle url=www.langchao.com:8080 */
if((url_end=strchr(url,':'))!=NULL){

#ifdef DEBUG
printf("URL:PORT=%s\n",url);
#endif

/* get http request URL */
url_tmp=malloc(100);
memcpy(url_tmp,url,url_end-url);
url=url_tmp;

#ifdef DEBUG
printf("URL=%s\n",url);
#endif

/* get http request port */
url_tmp=strstr(url_end,":");
port_tmp=atoi(++url_tmp);
port=port_tmp;

#ifdef DEBUG
printf("port=%d\n",port);
#endif

free(url_tmp);
}

/* get the remote host IP address */

/* if URL is IP address */
if((hs=gethostbyname(url))==NULL){
perror("gethostbyname() error");
close(connfd);
free(url);
return;
}

/* create proxy Tcp socket */
if((proxy_sockfd=socket(AF_INET,SOCK_STREAM,0))==-1){
perror("proxy socket error");
close(connfd);
free(url);
return;
}

//printf("proxy_sockfd=%d\n",proxy_sockfd);

/* initialize proxy socet */
bzero(&proxy,sizeof(proxy));
proxy.sin_family=AF_INET;
proxy.sin_port=htons(port);
//#ifdef TCP
proxy.sin_addr=*((struct in_addr*)inet_addr("10.14.11.223"));
//proxy.sin_addr=*((struct in_addr*)hs->h_addr);


#ifdef DEBUG
printf("ip address=%s\n",inet_ntoa(proxy.sin_addr));
#endif

/* connect http server */
if(connect(proxy_sockfd,(SockAddr*)&proxy,sizeof(SockAddr))==-1){
perror("proxy connect error");
close(connfd);
free(url);
return;
}

/* send request to http server */
send(proxy_sockfd,recv_buf,num,0);

#ifdef DEBUG
printf("\n================proxy request================\n");
printf("%s\n",recv_buf);
printf("\n============================================\n");
#endif

/*
FD_ZERO(&read_set);
FD_SET(connfd,&read_set);
FD_SET(proxy_sockfd,&read_set);
*/

while(1){

#ifdef DEBUG
printf("\n==========while begin==============\n");
#endif

FD_ZERO(&read_set);
FD_SET(connfd,&read_set);
FD_SET(proxy_sockfd,&read_set);


#ifdef DEBUG
printf("connfd=%d,proxy_sockfd=%d\n",connfd,proxy_sockfd);
printf("\n========select forward===============\n");
#endif

num_select=select((connfd>proxy_sockfd?connfd:proxy_sockfd)+1,&read_set,NULL,NULL,NULL);

#ifdef DEBUG
printf("num_select=%d\n",num_select);
printf("\n========select backwork==============\n");
#endif

if(FD_ISSET(connfd,&read_set)){
bzero(recv_buf,MAX_DATA_SIZE);
num=recv(connfd,recv_buf,MAX_DATA_SIZE,0);

#ifdef DEBUG
printf("\n===============proxy request again====================\n");
printf("%s\n",recv_buf);
printf("\n==================================================\n");
#endif

if(num==0 || num==-1){

#ifdef DEBUG
printf("client[%d] clsoed\n",connfd);
#endif

close(connfd);
close(proxy_sockfd);
break;
}

send(proxy_sockfd,recv_buf,num,0);
//FD_CLR(connfd,&read_set);
}

if(FD_ISSET(proxy_sockfd,&read_set)){
bzero(recv_buf,MAX_DATA_SIZE);
num=recv(proxy_sockfd,recv_buf,MAX_DATA_SIZE,0);

#ifdef DEBUG
printf("\n================http server response========================\n");
printf("%s\n",recv_buf);
printf("\n===========================================================\n");
#endif

if(num==0 || num==-1){

#ifdef DEBUG
printf("server[%d] closed\n",proxy_sockfd);
#endif

close(connfd);
close(proxy_sockfd);
break;
}

send(connfd,recv_buf,num,0);
//FD_CLR(proxy_sockfd,&read_set);
}

#ifdef DEBUG
printf("\n=====================while end============================\n");
#endif

} //end while

free(url);

//printf("ip=%s\n",inet_ntoa(proxy.sin_addr));
}

void* start_thread(void* arg){
int connfd;
connfd=*(int*)(arg);

#ifdef DEBUG
printf("\n>>>>>>>>>>>>>>>>>>>>>>>this is the %d thread>>>>>>>>>>>>>>>>>>>>>>>>>>>\n",index_thread++);
#endif

handle_request(connfd);
pthread_exit(NULL);
}

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

[jikes]

#include <stdio.h>
int main()
{
struct sockaddr_in conn_addr;
int sock_fd;
char buf[2048];
if((sock_fd=socket(AF_INET,SOCK_DGRAM,0))<0)
exit(1);
bzero((char *)&conn_addr,sizeof(conn_addr));
conn_addr.sin_family = AF_INET;
conn_addr.sin_addr.s_addr = htonl(INADDR_ANY);
conn_addr.sin_port = htons(30000);
socklen_t len=sizeof(conn_addr);

if(bind(sock_fd,(struct sockaddr *)&conn_addr,sizeof(struct sockaddr_in))<0)
exit(1);
for(;;){
if(recvfrom(sock_fd,&buf,2048,0,(struct sockaddr *)&conn_addr,&len)>0)
{
//...
}
else
{
printf("receive error!\n");

}
}
return -1;
}

[xfzhao_cn]

<unix network programming vol 1>

[borland_boy]

//---------------------------------------------------------------------
server.c

#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dirent.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/times.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "talker.h"

int main(int argc, char **argv)
{
int socket_des;
int read_len;
int address_len;
int real_send_len;
int real_receive_len;
char server_input[BUFFER_SIZE];
char client_message[BUFFER_SIZE];
struct timeval tv;
struct sockaddr_in address;
fd_set readfds;

tv.tv_sec = 20;
tv.tv_usec = 500000;

// 首先建立一个 socket, 族为 AF_INET, 类型为 SOCK_STREAM.
// AF_INET = ARPA Internet protocols 即使用 TCP/IP 协议族
// SOCK_STREAM 类型提供了顺序的, 可靠的, 基于字节流的全双工连接.
// 由于该协议族中只有一个协议, 因此第三个参数为 0
socket_des = socket(AF_INET, SOCK_STREAM, 0);

address.sin_family = AF_INET;
address.sin_addr.s_addr = htonl(INADDR_ANY);
address.sin_port = htons(PORT);
bzero(address.sin_zero,8);
address_len = sizeof(address);

// 再将这个 socket 与某个地址进行绑定.
// serv_addr 包括 sin_family = AF_INET 协议族同 socket
// sin_addr.s_addr = htonl( INADDR_ANY) server 所接受的所有其他
// 地址请求建立的连接.
// sin_port = htons( SERV_TCP_PORT) server 所监听的端口
// 在本程序中, server 的 IP和监听的端口都存放在 config 文件中.
bind(socket_des, (struct sockaddr *)&address, address_len);

// 地址绑定之后, server 进入监听状态.
// MAX_CLIENT 是可以同时建立连接的 client 总数.
listen(socket_des, 5);

system("clear");

while(1) {
int len;
pid_t pid;
int client_sock_des;
struct sockaddr_in client_address;

len = sizeof(client_address);
client_sock_des = accept(socket_des,(struct sockaddr *)&client_address, &len);

if( (pid = fork()) == 0){
close(socket_des);
printf("Get connection from client %s\n",inet_ntoa(client_address.sin_addr));
real_send_len = send(client_sock_des,"welcome connect to me\n",strlen("welcome connect to me\n"),0);
while(1){
FD_ZERO(&readfds);
FD_SET(STDIN,&readfds);
FD_SET(client_sock_des,&readfds);
select(client_sock_des+1,&readfds,NULL,NULL,&tv);

if(FD_ISSET(STDIN,&readfds)){
//send to server
read_len = read(STDIN,server_input,sizeof(server_input));
server_input[read_len] = '\0';
real_send_len = send(client_sock_des,server_input,read_len,0);
//need some process here
printf("send to client::%s",server_input);
}else if(FD_ISSET(client_sock_des,&readfds)){
//receive and send to output
real_receive_len = recv(client_sock_des,client_message,BUFFER_SIZE,0);
if(real_receive_len==0){
exit(0);
}else{
client_message[real_receive_len] = '\0';
printf("from client::%s",client_message);
}
}else{
close(client_sock_des);
printf("time out\n");
exit(1);
}
}
close(client_sock_des);
exit(0);
}
close(client_sock_des);
}
exit(0);
}
//---------------------------------------------------------------------

client.c

#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dirent.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/times.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "talker.h"

int main(int argc, char **argv)
{
int rtval;
int read_len;
int socket_des;
int address_len;
int real_send_len;
int real_receive_len;
char client_input[BUFFER_SIZE];
char server_message[BUFFER_SIZE];
struct timeval tv;
struct sockaddr_in address;
fd_set readfds;


tv.tv_sec = 20;
tv.tv_usec = 500000;

if(argc!=2){
system("clear");
printf("Usage:client servername(IP)\n");
exit(1);
}

socket_des = socket(AF_INET, SOCK_STREAM, 0);
address.sin_family = AF_INET;
address.sin_addr.s_addr = inet_addr(argv[1]);
address.sin_port = htons(PORT);
bzero(address.sin_zero,8);
address_len = sizeof(address);

rtval = connect(socket_des, (struct sockaddr *)&address, address_len);
if(rtval == -1){
perror("connect");
exit(1);
}

while(1){
FD_ZERO(&readfds);
FD_SET(STDIN,&readfds);
FD_SET(socket_des,&readfds);
select(socket_des+1,&readfds,NULL,NULL,&tv);

if(FD_ISSET(STDIN,&readfds)){
//send to server
read_len = read(STDIN,client_input,sizeof(client_input));
client_input[read_len] = '\0';
real_send_len = send(socket_des,client_input,read_len,0);
printf("send to server::%s",client_input);
}else if(FD_ISSET(socket_des,&readfds)){
//receive and send to output
real_receive_len = recv(socket_des,server_message,BUFFER_SIZE,0);
if(real_receive_len==0){
exit(0);
}else{
server_message[real_receive_len] = '\0';
printf("from server::%s",server_message);
}
}else{
printf("time out\n");
exit(1);
}
}
close(socket_des);
}
//---------------------------------------------------------------------

talker.h

#define STDIN 0
#define STDOUT 1
#define STDERR 2
#define PORT 1248
#define BUFFER_SIZE 1024
//---------------------------------------------------------------------

[ptfcas]

mark