linux编程socket程序的编译语句

server端：

#include <stdio.h>

#include <unistd.h>

#include <stdlib.h>

#include<string.h>

#include <ctype.h>

#include <sys/socket.h>

#include <arpa/inet.h>

#define MAX_LINE 100

int main()

{

struct sockaddr_in server

struct sockaddr_in client

int server_fd

int client_fd

socklen_t len

char buf[MAX_LINE]//用于存储传送内容到缓冲区

char addr_ip[INET_ADDRSTRLEN]//存储客户端地址缓冲区

int port = 8000//端口号8000

int n//读写字节数

bzero(&server,sizeof(server))//清空地址结构

server.sin_family = AF_INET//使用ipv4

server.sin_addr.s_addr = INADDR_ANY//服务器可以接受任意地址

server.sin_port = htons(port)//把端口号转成网络字节序

server_fd = socket(AF_INET,SOCK_STREAM,0)//创立套接字，使用tcp协议

bind(server_fd,(struct sockaddr *)&server,sizeof(server))//将地址和套接字绑定

listen(server_fd,10)//开始监听

printf("waiting```\n")

while(1)

{

client_fd = accept(server_fd,(struct sockaddr *)&client,&len)

n = read(client_fd,buf,MAX_LINE)//读取客户端来的消息

inet_ntop(AF_INET,&client.sin_addr,addr_ip,sizeof(addr_ip))

printf("client ip is : %s , port is : %d\n",addr_ip,ntohs(client.sin_port))

printf("content is : %s\n",buf)//打印客户端信息

write(client_fd,buf,n)//转发回去给客户端

close(client_fd)

}

if(close(client_fd) == -1)

{

perror("fail to close")

exit(1)

}

return 0

}

client端：

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <arpa/inet.h>

#define MAX_LINE 100

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

{

struct sockaddr_in server//服务器地址

char buf[MAX_LINE]

int server_fd

int port = 8000

char *str = "test string"//默认字符串

if(argc >1)

{

str = argv[1]//从命令参数中取得用户输入的串

}

bzero(&server,sizeof(server))//清空地址结构

server.sin_family = AF_INET//使用ipv4

inet_pton(AF_INET,"192.168.228.129",&server.sin_addr)

server.sin_port = htons(port)

server_fd = socket(AF_INET,SOCK_STREAM,0)//创建套接字

connect(server_fd,(struct sockaddr *)&server,sizeof(server))

write(server_fd,str,strlen(str) + 1)

//因为是本机测试，所以不用考虑延时

read(server_fd,buf,MAX_LINE)

printf("recieve from server :%s\n",buf)

close(server_fd)

return 0

}

//源码来自于网络，谁写也都类似，都是基于tcp的三次握手协议来写的

客户端建立socket客户端与服务端socket交互，服务端通过广播或单通道的方式将处理后的数据下发

2、服务端需要建立socket服务，采用何种技术不重要，java/c/.net这些都可以

3、客户端需要实现socket客户端，采用何种技术也不重要，java/c/.net这些都可以

4、服务端与客户端的交互报文协议和交互流程需要事先约定好

5、具体实现举例，给你提供个思路：

a. 服务端使用java编写，编译后启动，启动后就是实现一个socket的服务端，网上很多类似代码，在linux下安装一个jre就可以了

b.服务端采用C实现socket服务端，可以考虑使用ACE框架来简化开发，linux下g++编译很方便，编译后直接运行，前提是ACE等相关工具和环境需要配置好

c.服务端构建一个J2EE的web应用，然后在linux下部署在tomcat下，启动部分与方法a一致

6、其实很简单，关键是了解聊天室的原理其实就是一个套接字通讯，与具体的技术或编程工具无关

另外,团IDC网上有许多产品团购,便宜有口碑

哦字符串回显啊unix网络编程有好几个版本，你可以去网上下它的源代码（百度搜UNIX网络编程 源代码），呃大部分被我的改的不成样了，发个能用的给看看吧

//server

#include<stdio.h>

#include<sys/socket.h>

#include<arpa/inet.h>

#include<netinet/in.h>

#include<stdlib.h>

#include<string.h>

#include<unistd.h>

#include<errno.h>

#include<signal.h>

#define SERVPORT 1956

#define MAXLINE 100

typedef void Sigfunc(int)

void sig_chld(int signo)

{

        pid_t pid

        int stat

        while( (pid = waitpid(-1, &stat, WNOHANG)) > 0)

                printf("child %d terminated\n", pid)

        return

}

//read data from client, and write back to them

void str_echo(int sockfd)

{

        ssize_t n

        char buf[MAXLINE]

        again:

        while( (n = read(sockfd, buf, MAXLINE)) > 0 )

                write(sockfd, buf, n)

        if(n < 0 && errno ==EINTR)

                goto again

        else if(n < 0 )

                printf("error\n")

}

int main(int argc, char** argv)

{

        int listenfd, connfd

        socklen_t clilen

        pid_t childpid

        struct sockaddr_in servaddr, cliaddr

        if( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0 )

        {

                printf("socket fd error\n")

                return -1

        }

        bzero(&servaddr, sizeof(servaddr))

        servaddr.sin_family = AF_INET

        servaddr.sin_addr.s_addr = htonl(INADDR_ANY)

        servaddr.sin_port = htons(SERVPORT)

        if( bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) <0 )

        {

                printf("bind error\n")

                return -1

        }

        int backlong = 0

        if(listen(listenfd, backlong) <0 )

        {

                printf("listen error\n")

                return -1

        }

        signal(SIGCHLD, sig_chld)

        for()

        {

                clilen = sizeof(cliaddr)

                if( (connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &clilen)) < 0)

                {

                        if(errno == EINTR)      continue

                        else printf("accept error\n")

                        return 0

                }

                printf("accept \n")

                if( (childpid = fork()) == 0 )

                {

                        close(listenfd)    //close child's listen socket

                        str_echo(connfd)

                        exit(0)

                }

                close(connfd)

        }

 } //client

#include<stdio.h>

#include<sys/socket.h>

#include <arpa/inet.h>

#include <netinet/in.h>

#include <stdlib.h>

#include <string.h>

#define MAXLINE 10

int main(int argc, char ** argv)

{

        int sockfd, n

        char recvline[MAXLINE+1]

        struct sockaddr_in servaddr,binaddr

        if(argc != 2)

        {

                printf("usage: <IPADDRESS>\n")

                return -1

        }

        if( (sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)

        {

                printf("socket error\n")

                return -1

        }

        bzero(&servaddr, sizeof(servaddr))

        servaddr.sin_family = AF_INET

        servaddr.sin_port = htons(15)

        if(inet_pton(AF_INET, argv[1], &servaddr.sin_addr)<=0 )    

        {

                printf("inet_pton error for &s \n", argv[1])

                return -1

        }

        int bindSock

        binaddr.sin_family = AF_INET

        inet_pton(AF_INET, "222.26.224.56", &binaddr.sin_addr)

        binaddr.sin_port = htons(20000)

        int reuse0 = 1

        if(setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (char *)&reuse0, sizeof(reuse0)) == -1)

        {

                printf("set socket error\n")

                return -1

        }

        if( bind(sockfd, (struct sockaddr *)&binaddr, sizeof(servaddr)) <0 )

        {

                printf("bind error\n")

                return -1

        }

        if( connect(sockfd, (struct sockaddr*) &servaddr, sizeof(servaddr) ) < 0 )

        {

                printf("connection refuse\n")

                return -1

        }

        while( (n = read(sockfd, recvline, MAXLINE)) > 0 )

        {

                recvline[n] = 0

                if(fputs(recvline, stdout) == EOF)

                {

                        printf("fputs error")

                        return -1

                }

                printf("\n")

        }

        if(n < 0 )

        {

                printf("read error")

                return -1

        }

}

---