linux网络编程实例,linux系统网络编程主要是学什么？？要用到哪些概念和函数？？最好是举例说明，要详细些？
linux网络编程实例,linux系统网络编程主要是学什么？？要用到哪些概念和函数？？最好是举例说明，要详细些？详细介绍
本文目录一览： linux下socket 网络编程(客户端向服务器端发送文件) 求源代码 大哥大姐帮帮忙 。。谢谢
#include
#include
#include
#include
#include
#include
#include
main()
{
int serverfd=socket(AF_INET,SOCK_STREAM,0);
if(serverfd==-1) printf("服务器socket建立失败:%m\n"),exit(-1);
printf("服务器socket建立成功!\n");
struct sockaddr_in addr;
addr.sin_family=AF_INET;
addr.sin_port=htons(11112);
inet_aton("192.168.180.92",&addr.sin_addr);
int r=bind(serverfd,(struct sockaddr*)&addr,sizeof(addr));
if(r==-1) printf("绑定地址失败:%m\n"),exit(-1);
printf("绑定地址成功!\n");
r=listen(serverfd,10);
if(r==-1) printf("监听服务socket变化失败:%m\n"),exit(-1);
printf("监听服务器socket成功!\n");
struct sockaddr_in caddr;
socklen_t len;
while(1)
{
len=sizeof caddr;
int fd=accept(serverfd,(struct sockaddr*)&caddr,&len);
printf("有人连接:%s:%d\n",
inet_ntoa(caddr.sin_addr),
ntohs(caddr.sin_port));
}
}
这是服务器端的，客户端的只要去掉监听，连接，再把发送接收数据改一下，就能用了
server:
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define MAXDATASIZE 1024
#define SERVPORT 19999
#define BACKLOG 10
int SendFileToServ(const char *path, const char *FileName, const char *ip)
{
#define PORT 20002
int sockfd;
int recvbytes;
char buf[MAXDATASIZE];
char send_str[MAXDATASIZE];
char filepath[128] = {0};
struct sockaddr_in serv_addr;
FILE *fp;
sprintf(filepath, "%s%s", path, FileName);
if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1)
{
perror("socket");
return 1;
}
bzero(&serv_addr,sizeof(struct sockaddr_in));
serv_addr.sin_family=AF_INET;
serv_addr.sin_port=htons(PORT);
inet_aton(ip, &serv_addr.sin_addr);
int IErrCount = 0;
again:
if(connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(struct sockaddr))==-1)
{
if (5 == IErrCount)
return 1;
IErrCount++;
perror("connect");
sleep(2);
goto again;
}
//if ((fp = fopen(FileName, "rb")) == NULL)
if ((fp = fopen(filepath, "rb")) == NULL)
{
perror("fopen ");
return 1;
}
recvbytes = write(sockfd, FileName, strlen(FileName));
recvbytes = read(sockfd, buf, MAXDATASIZE);
if (!memcmp(buf, "sendmsg", 7))
{
while(fgets(send_str, MAXDATASIZE, fp))
{
recvbytes = write(sockfd, send_str, strlen(send_str));
recvbytes = read(sockfd, buf, MAXDATASIZE);
if (recvbytes <= 0)
{
fclose(fp);
close(sockfd);
return 1;
}
if (memcmp(buf, "goon", 4))
{
fclose(fp);
close(sockfd);
return 1;
}
}
recvbytes = write(sockfd, "end", 3);
}
else
{
fclose(fp);
close(sockfd);
return 1;
}
memset(buf, 0, MAXDATASIZE);
if (read(sockfd, buf, MAXDATASIZE) <= 0)
{
close(sockfd);
return 2;
}
char *Eptr = "nginx reload error";
//printf("bf[%s]\n", buf);
int ret;
ret = strncmp(buf, Eptr, strlen(Eptr));
//printf("%d\n", ret);
if (!ret)
{
close(sockfd);
return 2;
}
close(sockfd);
return 0;
}
int mysyslog(const char * msg)
{
FILE *fp;
if ((fp = fopen("/tmp/tmp.log", "a+")) == NULL)
{
return 0;
}
fprintf(fp, "[%s]\n", msg);
fclose(fp);
return 0;
}
static void quit_handler(int signal)
{
kill(0, SIGUSR2);
syslog( LOG_NOTICE, "apuserv quit...");
// do something exit thing ,such as close socket ,close mysql,free list
// .....
//i end
exit(0);
}
static int re_conf = 0;
static void reconf_handler(int signal)
{
re_conf=1;
syslog(LOG_NOTICE,"apuserv reload configure file .");
// 请在循环体中判断，如果re_conf == 1，请再次加载配置文件。
}
static int isrunning(void)
{
int fd;
int ret;
struct flock lock;
lock.l_type = F_WRLCK;
lock.l_whence = 0;
lock.l_start = 0;
lock.l_len = 0;
const char *lckfile = "/tmp/apuserv.lock";
fd = open(lckfile,O_WRONLY|O_CREAT);
if (fd < 0) {
syslog(LOG_ERR,"can not create lock file: %s\n",lckfile);
return 1;
}
if ((ret = fcntl(fd,F_SETLK,&lock)) < 0) {
ret = fcntl(fd,F_GETLK,&lock);
if (lock.l_type != F_UNLCK) {
close(fd);
return lock.l_pid;
}
else {
fcntl(fd,F_SETLK,&lock);
}
}
return 0;
}
int MyHandleBuff(const char *buf, char *str, char *FileName, char *pth)
{
sscanf(buf, "%s %s %s", pth, FileName, str);
printf("path=%s\nfilename=%s\nip=%s\n", pth, FileName, str);
return 0;
}
int main(int argc, char **argv)
{
int sockfd,client_fd;
socklen_t sin_size;
struct sockaddr_in my_addr,remote_addr;
char buff[MAXDATASIZE];
int recvbytes;
#if 1
int pid ;
char ch ;
int ret;
int debug = 0;
signal(SIGUSR1, SIG_IGN);
signal(SIGUSR2, SIG_IGN);
signal(SIGHUP, SIG_IGN);
signal(SIGTERM, quit_handler);
syslog(LOG_NOTICE,"apuserver start....");
while ((ch = getopt(argc, argv, "dhV")) != -1) {
switch (ch) {
case 'd':
debug = 1;
break;
case 'V':
printf("Version:%s\n","1.0.0");
return 0;
case 'h':
printf(" -d use daemon mode\n");
printf(" -V show version\n");
return 0;
default:
printf(" -d use daemon mode\n");
printf(" -V show version\n");
}
}
if (debug && daemon(0,0 ) ) {
return -1;
}
if (isrunning()) {
fprintf(stderr, "apuserv is already running\n");
syslog(LOG_INFO,"apuserv is already running\n");
exit(0);
}
while (1) {
pid = fork();
if (pid < 0)
return -1;
if (pid == 0)
break;
while ((ret = waitpid(pid, NULL, 0)) != pid) {
syslog(LOG_NOTICE, "waitpid want %d, but got %d", pid, ret);
if (ret < 0)
syslog(LOG_NOTICE, "waitpid errno:%d", errno);
}
kill(0, SIGUSR2);
sleep(1);
syslog(LOG_NOTICE,"restart apuserver");
}
signal(SIGHUP, reconf_handler);
signal(SIGPIPE, SIG_IGN);
signal(SIGUSR1,SIG_IGN);
signal(SIGUSR2, SIG_DFL);
signal(SIGTERM, SIG_DFL);
#endif
if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1)
{
perror("socket");
exit(1);
}
bzero(&my_addr,sizeof(struct sockaddr_in));
my_addr.sin_family=AF_INET;
my_addr.sin_port=htons(SERVPORT);
my_addr.sin_addr.s_addr = htonl(INADDR_ANY);
if(bind(sockfd,(struct sockaddr *)&my_addr,sizeof(struct sockaddr))==-1)
{
perror("bind");
exit(1);
}
if(listen(sockfd,BACKLOG)==-1)
{
perror("listen");
exit(1);
}
int nret;
while(1)
{
sin_size = sizeof(struct sockaddr_in);
if((client_fd = accept(sockfd, (struct sockaddr *)&remote_addr, &sin_size))==-1)
{
perror("falied accept");
continue;
}
memset(buff, 0, MAXDATASIZE);
recvbytes = read(client_fd, buff, MAXDATASIZE);
char str[16] = {0};
char FileName[128] = {0};
char path[128] = {0};
MyHandleBuff(buff, str, FileName, path);
if (recvbytes > 0)
{
nret = SendFileToServ(path, FileName, str);
printf("nret[%d]\n", nret);
if (1 == nret)
write(client_fd, "send file error", 15);
else if(2 == nret)
write(client_fd, "reload nginx error", 18);
else
write(client_fd, "succ", 4);
}
close(client_fd);
}
}
_________________________________________________
client:
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define MAXDATASIZE 1024
#define SERVPORT 20002
#define BACKLOG 10
int mysyslog(const char * msg)
{
FILE *fp;
if ((fp = fopen("/tmp/tmp.log", "a+")) == NULL)
{
return 0;
}
fprintf(fp, "[%s]\n", msg);
fclose(fp);
return 0;
}
static void quit_handler(int signal)
{
kill(0, SIGUSR2);
syslog( LOG_NOTICE, "apuserv quit...");
// do something exit thing ,such as close socket ,close mysql,free list
// .....
//i end
exit(0);
}
static int re_conf = 0;
static void reconf_handler(int signal)
{
re_conf=1;
syslog(LOG_NOTICE,"apuserv reload configure file .");
// ????·???????1nf == 1￡???′μ?????
static int isrunning(void)
{
int fd;
int ret;
struct flock lock;
lock.l_type = F_WRLCK;
lock.l_whence = 0;
lock.l_start = 0;
lock.l_len = 0;
const char *lckfile = "/tmp/dstserver.lock";
fd = open(lckfile,O_WRONLY|O_CREAT);
if (fd < 0) {
syslog(LOG_ERR,"can not create lock file: %s\n",lckfile);
return 1;
}
if ((ret = fcntl(fd,F_SETLK,&lock)) < 0) {
ret = fcntl(fd,F_GETLK,&lock);
if (lock.l_type != F_UNLCK) {
close(fd);
return lock.l_pid;
}
else {
fcntl(fd,F_SETLK,&lock);
}
}
return 0;
}
int main(int argc, char **argv)
{
int sockfd,client_fd;
socklen_t sin_size;
struct sockaddr_in my_addr,remote_addr;
char buff[MAXDATASIZE];
int recvbytes;
#if 1
int pid ;
char ch ;
int ret;
int debug = 0;
signal(SIGUSR1, SIG_IGN);
signal(SIGUSR2, SIG_IGN);
signal(SIGHUP, SIG_IGN);
signal(SIGTERM, quit_handler);
syslog(LOG_NOTICE,"dstserver start....");
while ((ch = getopt(argc, argv, "dhV")) != -1) {
switch (ch) {
case 'd':
debug = 1;
break;
case 'V':
printf("Version:%s\n","1.0.0");
return 0;
case 'h':
printf(" -d use daemon mode\n");
printf(" -V show version\n");
return 0;
default:
printf(" -d use daemon mode\n");
printf(" -V show version\n");
}
}
if (debug && daemon(0,0 ) ) {
return -1;
}
if (isrunning()) {
fprintf(stderr, "dstserver is already running\n");
syslog(LOG_INFO,"dstserver is already running\n");
exit(0);
}
while (1) {
pid = fork();
if (pid < 0)
return -1;
if (pid == 0)
break;
while ((ret = waitpid(pid, NULL, 0)) != pid) {
syslog(LOG_NOTICE, "waitpid want %d, but got %d", pid, ret);
if (ret < 0)
syslog(LOG_NOTICE, "waitpid errno:%d", errno);
}
kill(0, SIGUSR2);
sleep(1);
syslog(LOG_NOTICE,"restart apuserver");
}
signal(SIGHUP, reconf_handler);
signal(SIGPIPE, SIG_IGN);
signal(SIGUSR1,SIG_IGN);
signal(SIGUSR2, SIG_DFL);
signal(SIGTERM, SIG_DFL);
#endif
if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1)
{
perror("socket");
exit(1);
}
bzero(&my_addr,sizeof(struct sockaddr_in));
my_addr.sin_family=AF_INET;
my_addr.sin_port=htons(SERVPORT);
my_addr.sin_addr.s_addr = htonl(INADDR_ANY);
if(bind(sockfd,(struct sockaddr *)&my_addr,sizeof(struct sockaddr))==-1)
{
perror("bind");
exit(1);
}
if(listen(sockfd,BACKLOG)==-1)
{
perror("listen");
exit(1);
}
char filepath[MAXDATASIZE]= {0};
FILE *fp;
while(1)
{
sin_size = sizeof(struct sockaddr_in);
if((client_fd = accept(sockfd, (struct sockaddr *)&remote_addr, &sin_size))==-1)
{
perror("falied accept");
continue;
}
memset(buff, 0, MAXDATASIZE);
recvbytes = read(client_fd, buff, MAXDATASIZE);
sprintf(filepath, "/etc/nginx/url_rule/%s", buff);
if ((fp = fopen(filepath, "wb")) == NULL)
{
perror("fopen");
close(client_fd);
continue;
}
write(client_fd, "sendmsg", 7);
while(read(client_fd, buff, MAXDATASIZE))
{
if (!memcmp(buff, "end", 3))
{
fclose(fp);
break;
}
else
{
fprintf(fp, "%s", buff);
write(client_fd, "goon", 4);
}
}
//system("nginx -s reload");
char *Sptr = "nginx reload succ";
char *Eptr = "nginx reload error";
int ret;
ret = system("nginx -s reload");
printf("ret[%d]\n", ret);
if (ret != 0)
{
write(client_fd, Eptr, strlen(Eptr));
}
else
{
write(client_fd, Sptr, strlen(Sptr));
}
close(client_fd);
}
}
以前写的：内容忘记了。不是很复杂你可以自己看！
linux网络编程中如何实现服务器端多个read（）和客户端write( )
你说的是服务器可以同时接收多个客户端发来的数据吧？
如果是这样的话，我有两种思路：
在客户端与服务器建立连接时候，服务器用pthread系列函数给客户端开一个线程，由于线程是并发执行的，因此可以实现多个客户端同时和服务器交互的情况。
使用select系统调用，把监听套接字加入到监听描述符集中，如果select成功返回说明描述符集合中有动作，这时候根据描述符类型进行操作，例如如果是监听套接字收到请求则我们服务器可以建立连接把客户套接字保存在集合中，如果是客户端套接字收到请求我们可以进行收发数据，但是用select的话，对单个客户的处理时间不能过长。
因此对应服务器有两种：并发服务器(思路1)和轮询服务器（思路2），但是我的主张是你学一下多线程，然后构建并发服务器好点，毕竟这是主流，你学了网络编程，在百度上搜索pthread简单学一下即可。不懂的话请继续提问，纯手打请支持o.0
一般的做法是使用多线程或者多进程来实现，不过这样做太消耗资源，通常会使用 select 或者第三方库 libev 等实现高并发
socket send/recv
TCP通信的模式如下图，比较固定，对着图编代码就可以了：
服务器的main函数：
int main(int argc, char **argv){ int listenfd, connfd; pid_t childpid; socklen_t clilen; struct sockaddr_in cliaddr, servaddr; //IPv4 address /*socket*/ listenfd = socket(AF_INET, SOCK_STREAM, 0);//创建一个TCP的socket if (-1 == listenfd) { perror("socket erro."); return -1; } /*bind*/ //首先初始化server的IP地址和端口,然后再与刚刚创建的socket绑定 bzero(&servaddr, sizeof(servaddr)); servaddr.sin_family = AF_INET;//设置协议簇 servaddr.sin_addr.s_addr = htonl(INADDR_ANY);//绑定本机的网卡 servaddr.sin_port = htons(1234);//绑定端口号，端口号可以随便取，大于1024就可以了 if (-1 == bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr))) { perror("bind error."); return -1; } /*listen*/ //到这里已经有了一个绑定了IP地址和端口号的socket了，但是这个socket是个主动的socket， //而作为server需要的是一个等待别的接入的被动的socket，所以得调用listen将这个socket设置为监听状态 //第二个参数表示服务器正在处理客户接入时的等待队列长度。 if (-1 == listen(listenfd, 10)) { perror("listen error."); return -1; } while (1) { clilen = sizeof(cliaddr); //调用accept等待客户的接入，同时accept会用第二个参数返回客户的IP地址， //通过第三个参数返回IP地址的实际大小，同时这个参数也是个值-结构参数，也就是 //在传递这个参数的时候，先给这个参数一个初始的值，然后函数中会根据具体的情况修改这个值， //所以这里传递的是指针。 //当客户接入后，将返回一个成功和客服连接的socket描述符，通过读写这个socket即可实现和客户的通信了 connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &clilen); if (-1 == connfd) { if (EINTR == errno) continue; perror("accept error."); return -1; } //通过fock创建子进程来处理客户请求，这里只是显示客户的IP地址、端口号和发送的文字， //并将客户发送的文字回传给客户。 if (0 == (childpid=fork())) {//fock返回0 说明是子进程 //这里并没有关闭服务器的监听socket,只是将其引用计数减一，因为fork出来的子进程对父进程做了拷贝， //所以这个监听socket的引用计数将由1变成2，而内核只有在一个socket的引用计数变为0才回去关闭它 close(listenfd); //通过和客户连接的socket和客户通信 str_echo(connfd, cliaddr); return 0; } //父进程将和客户连接的socket的引用计数减一，同样并没有关闭这个socket close(connfd); } return 0;}
服务器处理客户请求：
#define BSIZE 100void str_echo(int sockfd, struct sockaddr_in cliaddr){ ssize_t n; char buf[BSIZE]; while ((n=read(sockfd, buf, BSIZE))) {//读取客户发送的信息 buf[n] = '\0'; printf("IP: %s, PORT: %d: %s\n", \ inet_ntoa(cliaddr), ntohs(cliaddr.sin_port), buf); //输出信息 n_write(sockfd, buf, n);//将受到的信息发送回客户，n_write的实现下面给出 }}
客户端程序相对简单：
int main(int argc, char **argv){ int sockfd; struct sockaddr_in servaddr; if (2 != argc) { printf("usage: ./client 127.0.0.1");// return -1; } /*socket*/ sockfd = socket(AF_INET, SOCK_STREAM, 0); //创建一个socket if (-1 == sockfd) { perror("socket error."); return -1; } /*connect*/ //首先初始化要连接的服务器的IP地址和端口号，然后调用connect去连接这个服务器 bzero(&servaddr, sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_port = htons(1234); inet_pton(AF_INET, argv[1], &servaddr.sin_addr); if (-1 == connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr))) { perror("connect error."); return -1; } //连接成功后就可以通过这个socket来和服务器通信了 str_cli(stdin, sockfd);
return 0;}
n_write 和 readline
/*write n bytes to fd*/ssize_t n_write (int fd, void *buf, size_t n){ size_t nleft = n; ssize_t nwriten; char *bufp = buf;
while (nleft > 0) { if ((nwriten = write (fd, bufp, nleft)) <= 0) { if (EINTR == errno) nwriten = 0; else return -1; }
nleft -= nwriten; bufp += nwriten; }
return n;}
/*read line from fd*/ssize_t readline (int fd, void *buf, size_t maxlen){ ssize_t n, rc; char c, *bufp;
bufp = buf; for (n = 1; n < maxlen; n ++) {again: if (1 == (rc = read (fd, &c, 1))) { *bufp ++ = c; if ('\n' == c) break; /*newline is stored*/ } else if (rc == 0) { *bufp = 0; return (n - 1); /*EOF, n-1 bytes were read*/ } else { if (EINTR == errno) /*interrupt*/ goto again; return -1; /*Erro, set the errno by read ()*/ } } *bufp = 0; return n;}
运行结果：
因为客户端没有指定IP地址和端口，所以其IP和端口都是内核随机分配的。
Linux C语言网络编程问题！
给你解释了又有什么用?还不是让你交作业的.
unsigned int dir(char * server) {
int sck;//套接字变量
struct sockaddr_in serv_adr; //远程主机的地址
struct hostent *host; //指向远程主机的指针
unsigned char databuf[FILEBUF_SIZE]; //数据
int bytes = 0, bytesread = 0; //字节数，读取到的字节数
host = gethostbyname(server); //根据远程主机的主机名，得到指向远程主机的指针
if (host == (struct hostent *) NULL) { //如果得到指向远程主机的指针失败，报告错误，并返回
perror("gethostbyname failed");
return 0;
}memset(&serv_adr, 0, sizeof(serv_adr)); //初始化远程主机的地址，结构体内所有成员清零
serv_adr.sin_family = AF_INET; //设置地址类型
memcpy(&serv_adr.sin_addr, host->h_addr, host->h_length);//取出指向远程主机的指针中包含的地址信息，赋给远程主机地址变量
serv_adr.sin_port = htons(SERVICE_PORT);//设置端口号，比如http服务对应80端口，ftp对应21端口
if ((sck = socket(AF_INET, SOCK_STREAM, 0)) < 0) { //如果建立TCP协议的套接字失败，报告错误，并返回
perror("error on socket()");
return 0;
}
if (connect(sck, (struct sockaddr *)&serv_adr, sizeof(serv_adr)) < 0) {//如果使用该套接字连接到远程主机失败，报告错误，并返回
perror("error on connect()");
return 0;
}write(sck, "DI\n\n", 4); //连接成功，发送内容为"DI\n\n"的消息，远程主机收到该消息，解析后生成目录列表，并将目录列表信息传递回来
printf("Remote directory listing:\n");//输出提示信息“远程主机正在生成目录列表”
while ((bytes = read(sck, databuf, FILEBUF_SIZE)) > 0) { //从套接字的数据流中读取远程主机的返回信息（即目录列表），每次读取FILEBUF_SIZE个字节，直到全部读取完毕
write(fileno(stdout), databuf, bytes);//将每次读到的数据，输出到标准输出流(stdout)，即屏幕上
bytesread += bytes;//接收到的字节数累加
}
close(sck); /* Close the socket */ //通信完成，关闭套接字，关闭连接
return bytesread; //返回读取到的字节数（即远程主机返回的信息的大小）
}
linux 网络编程 sendto 问题
sendto（经socket传送数据）
相关函数 send , sendmsg,recv , recvfrom , socket
表头文件 #include < sys/types.h >
#include < sys/socket.h >
定义函数 int sendto ( int s , const void * msg, int len, unsigned int flags, const
struct sockaddr * to , int tolen ) ;
函数说明 sendto() 用来将数据由指定的socket传给对方主机。参数s为已建好连线的socket,如果利用UDP协议则不需经过连线操作。参数msg指向欲连线的数据内容，参数flags 一般设0，详细描述请参考send()。参数to用来指定欲传送的网络地址，结构sockaddr请参考bind()。参数tolen为sockaddr的结果长度。
返回值 成功则返回实际传送出去的字符数，失败返回－1，错误原因存于errno 中。
错误代码 EBADF 参数s非法的socket处理代码。
EFAULT 参数中有一指针指向无法存取的内存空间。
WNOTSOCK canshu s为一文件描述词，非socket。
EINTR 被信号所中断。
EAGAIN 此动作会令进程阻断，但参数s的soket为补课阻断的。
ENOBUFS 系统的缓冲内存不足。
EINVAL 传给系统调用的参数不正确。
范例 #include < sys/types.h >
#include < sys/socket.h >
# include
#include
#define PORT 2345 /*使用的port*/
main(){
int sockfd,len;
struct sockaddr_in addr;
char buffer[256];
/*建立socket*/
if(sockfd=socket (AF_INET,SOCK_DGRAM,0))<0){
perror (“socket”);
exit(1);
}
/*填写sockaddr_in 结构*/
bzero ( &addr, sizeof(addr) );
addr.sin_family=AF_INET;
addr.sin_port=htons(PORT);
addr.sin_addr=hton1(INADDR_ANY) ;
if (bind(sockfd, &addr, sizeof(addr))<0){
perror(“connect”);
exit(1);
}
while(1){
bezro(buffer,sizeof(buffer));
len = recvfrom(socket,buffer,sizeof(buffer), 0 , &addr &addr_len);
/*显示client端的网络地址*/
printf(“receive from %s\n “ , inet_ntoa( addr.sin_addr));
/*将字串返回给client端*/
sendto(sockfd,buffer,len,0,&addr,addr_len);”
}
}
显然这里没有绑定啊，直接创建一个socket怎么能用呢？查一下bind函数吧。
求助 linux c 编写openssl socket套接字通信 运行时报错 网络编程 不知道该怎么办啊
1.TCP流式套接字的编程步骤
在使用之前须链接库函数：工程->设置->Link->输入ws2_32.lib，OK！
SOCKET sockSrv=socket(AF_INET,SOCK_STREAM,0);//创建套接字（socket）。
SOCKADDR_IN addrSrv;
addrSrv.sin_addr.S_un.S_addr=htonl(INADDR_ANY);//转换Unsigned short为网络字节序的格式
addrSrv.sin_family=AF_INET;
addrSrv.sin_port=htons(6000);
客户端代码如下：
#include
#include
void main()
{
WORD wVersionRequested;
WSADATA wsaData;
int err;
wVersionRequested = MAKEWORD( 1, 1 );
err = WSAStartup( wVersionRequested, &wsaData );加载套接字库
if ( err != 0 ) {
return;
}
if ( LOBYTE( wsaData.wVersion ) != 1 ||
HIBYTE( wsaData.wVersion ) != 1 ) {
WSACleanup()( );
return;
}
SOCKET sockClient=socket(AF_INET,SOCK_STREAM,0);创建套接字（socket）。
SOCKADDR_IN addrSrv;
addrSrv.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");
addrSrv.sin_family=AF_INET;
addrSrv.sin_port=htons(6000);
connect(sockClient,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));向服务器发出连接请求（connect）。
char recvBuf[100];和服务器端进行通信（send/recv）。
recv(sockClient,recvBuf,100,0);
printf("%s\n",recvBuf);
send(sockClient,"This is lisi",strlen("This is lisi")+1,0);
closesocket(sockClient);关闭套接字。
WSACleanup()();//必须调用这个函数清除参数
}
Linux环境下C开发_linux搭建c语言开发环境
一：C语言嵌入式Linux工程师的学习需要具备一定的C语言基础，C语言是嵌入式领域最重要也是最主要的编程语言，通过大量编程实例重点理解C语言的基础编程以及高级编程知识。包括：基本数据类型、数组、指针、结构体、链表、文件操作、队列、栈等。
二：Linux基础Linux操作系统的概念、安装方法，详细了解Linux下的目录结构、基本命令、编辑器VI,编译器GCC，调试器GDB和Make项目管理工具,ShellMakefile脚本编写等知识，嵌入式开发环境的搭建。
三：Linux系统编程重点学习标准I/O库，Linux多任务编程中的多进程和多线程，以及进程间通信(pipe、FIFO、消息队列、共享内存、signal、信号量等)，同步与互斥对共享资源访问控制等重要知识，主要提升对Linux应用开发的理解和代码调试的能力。
四：Linux网络编程计算机网络在嵌入式Linux系统应用开发过程中使用非常广泛，通过Linux网络发展、TCP/IP协议、socket编程、TCP网络编程、UDP网络编程、Web编程开发等方面入手，全面了解Linux网络应用程序开发。重点学习网络编程相关API，熟练掌握TCP协议服务器的编程方法和并发服务器的实现，了解HTTP协议及其实现方法，熟悉UDP广播、多播的原理及编程方法，掌握混合C/S架构网络通信系统的设计，熟悉HTML,Javascript等Web编程技术及实现方法。
五：数据结构与算法数据结构及算法在嵌入式底层驱动、通信协议、及各种引擎开发中会得到大量应用，对其掌握的好坏直接影响程序的效率、简洁及健壮性。此阶段的学习要重点理解数据结构与算法的基础内容，包括顺序表、链表、队列、栈、树、图、哈希表、各种查找排序算法等应用及其C语言实现过程。
六：C、QTC是Linux应用开发主要语言之一，本阶段重点掌握面向对象编程的基本思想以及C的重要内容。图形界面编程是嵌入式开发中非常重要的一个环节。由于QT具有跨平台、面向对象、丰富API、支持2D/3D渲染、支持XML、多国语等强大功能，在嵌入式领域的GUI开发中得到了广范的应用，在本阶段通过基于QT图形库的学习使学员可以熟练编写GUI程序，并移植QT应用程序到Cortex-A8平台。包括IDE使用、QT部件及布局管理器、信息与槽机制的应用、鼠标、键盘及绘图事件处理及文件处理的应用。
七：CortexA8、Linux平台开发通过基于ARMCortex-A8处理s5pv210了解芯片手册的基本阅读技巧，掌握s5pv210系统资源、时钟控制器、电源管理、异常中断控制器、nandflash控制器等模块，为底层平台搭建做好准备。Linux平台包括内核裁减、内核移植、交叉编译、GNU工具使用、内核调试、Bootloader介绍、制作与原理分析、根文件系统制作以及向内核中添加自己的模块，并在s5pv210实验平台上运行自己制作的Linux系统,集成部署Linux系统整个流程。同时了解Android操作系统开发流程。Android系统是基于Linux平台的开源操作系统，该平台由操作系统、中间件、用户界面和应用软件组成，是首个为移动终端打造的真正开放和完整的移动软件，目前它的应用不再局限于移动终端，还包括数据电视、机顶盒、PDA等消费类电子产品。
八：驱动开发驱动程序设计是嵌入式Linux开发工作中重要的一部分，也是比较困难的一部分。本阶段的学习要熟悉Linux的内核机制、驱动程序与用户级应用程序的接口，掌握系统对设备的并发操作。熟悉所开发硬件的工作原理，具备ARM硬件接口的基础知识，熟悉ARMCortex-A8处理器s5pv210各资源、掌握Linux设备驱动原理框架，熟悉工程中常见Linux高级字符设备、块设备、网络设备、USB设备等驱动开发，在工作中能独立胜任底层驱动开发。
以上就是列出的关于一名合格嵌入式Linux开发工程师所必学的理论知识，其实，作为一个嵌入式开发人员，专业知识和项目经验同样重要，所以在我们的理论学习中也要有一定的项目实践，锻炼自己的项目开发能力。
linux下网络编程遇到一个小问题，C语言哦
inet_ntoa()在出错的时候会返回NULL，printf( "%s", NULL)会导致段错误
你可以先判断inet_ntoa()是否出错，出错的话用errno打出错误原因，例如：
#include
#include
#include
#include
#include
#include
int main()
{
struct in_addr client;
char const *addr;
if ( ( addr = inet_ntoa( client)))
printf( "%s\n", addr);
else
printf( "inet_ntoa() failed: %s\n", strerror( errno));
return 0;
}
这条语句有问题哈.
“Server get connection from %s\n“这会把它当成字符串的，而不是按%s输出的.
应改成:
printf("Server get connection from ");
printf("%s\n ",inet_ntoa(client_addr.sin_addr));
改成这个试一下,能达到你要的效果.
http://baike.baidu.com/view/569200.htm
参考这个. inet_ntoa 函数 返回的是char 指针, 所以这里应该
printf("Server get connection from %s\n", *(inet_ntoa(client_addr.sin_addr)));
这样吧.
申请一个char buf[30];
buf=inet_ntoa(client_addr.sin_addr);
printf("Server get connection from %s\n",buf);
应该是没有开辟空间引起的段错误
求linux socket网络编程代码
我呢，在C,C++,SOCKET网络编程，数据库，网页，LINUX下写过一些模块，汇编（IBM 和 AT&T),这些方面有些经验，对了，winSDK,还有程序界面。 如果您仔细考虑之后觉得合着我的这样经验可以闯出那么一片天地，而且您...
即时通讯？ 太大了吧 聊天还差不多
Linux是多任务的操作系统，可在运行在Intel 80386及更高档次的PC机、ARMS、MIPS和PowerPC等多种计算机平台，已成为应用广泛、可靠性高、功能强大的计算机操作系统，Linux具有内核小、效率高、源代码开放等优点，还内含了TCP/IP网络协议，很适合在服务器领域使用，而服务器主要用途之一就是进行网络通信，随着计算机办公自动化处理技术的应用与推广，网络的不断普及，传统的纸张式文件传输方式已经不再适合发展的需要，人们更期待一种便捷、高效、环保、安全的网络传输方式.
协议概述TCP/IP即传输控制协议/网络协议[1]（Transmission Control Protocol/Internet Protocol），是一个由多种协议组成的协议族，他定义了计算机通过网络互相通信及协议族各层次之间通信的规范，图1描述了Linux对IP协议族的实现机制[2]。
Linux支持BSD的套接字和全部的TCP/IP协议，是通过网络协议将其视为一组相连的软件层来实现的，BSD套接字（BSD Socket）由通用的套接字管理软件支持，该软件是INET套接字层，用来管理基于IP的TCP与UDP端口到端口的互联问题，从协议分层来看，IP是网络层协议，TCP是一个可靠的端口到端口的传输层协议，他是利用IP层进行传接报文的，同时也是面向连接的，通过建立一条虚拟电路在不同的网路间传输报文，保证所传输报文的无丢失性和无重复性。用户数据报文协议（User Datagram Protocol，UDP）也是利用IP层传输报文，但他是一个非面向连接的传输层协议，利用IP层传输报文时，当目的方网际协议层收到IP报文后，必须识别出该报文所使用的上层协议（即传输层协议），因此，在IP报头上中，设有一个"协议"域（Protocol）。通过该域的值，即可判明其上层协议类型，传输层与网络层在功能说的最大区别是前者提供进程通信能力，而后者则不能，在进程通信的意义上，网络通信的最终地址不仅仅是主机地址，还包括可以描述进程的某种标识符，为此，TCP/UDP提出了协议端口（Protocol Port）的概念，用于标识通信的进程，例如，Web服务器进程通常使用端口80，在/etc/services文件中有这些注册了的端口地址。
对于TCP传输，传输节点间先要建立连接，然后通过该连接传输已排好序的报文，以保证传输的正确性，IP层中的代码用于实现网际协议，这些代码将IP头增加到传输数据中，同时也把收到的IP报文正确的传送到TCP层或UDP层。TCP是一个面向连接协议，而UDP则是一个非面向连接协议，当一个UDP报文发送出去后，Linux并不知道也不去关心他是否成功地到达了目的的主机，IP层之下，是支持所有Linux网络应用的网络设备层，例如点到点协议（Point to Point Protocol，PPP）和以太网层。网络设备并非总代表物理设备，其中有一些（例如回送设备）则是纯粹的软件设备，网络设备与标准的Linux设备不同，他们不是通过Mknod命令创建的，必须是底层软件找到并进行了初始化之后，这些设备才被创建并可用。因此只有当启动了正确设置的以太网设备驱动程序的内核后，才会有/dev/eth0文件，ARP协议位于IP层和支持地址解析的协议层之间。
网络通信原理所有的网络通信就其实现技术可以分为两种，线路交换和包交换，计算机网络一般采用包交换，TCP使用了包交换通信技术，计算机网络中所传输的数据，全部都以包（Packet）这个单位来发送，包由"报头"和"报文"组成，结构如图2所示，在"报头"中记载有发送主机地址，接收主机地址及与报文内容相关的信息等，在"报文"中记载有需要发送的数据，网络中的每个主机和路由器中都有一个路由寻址表，根据这个路由表，包就可以通过网络传送到相应的目的主机。
网络通信中的一个非常重要的概念就是套接字（Socket）[3，4]，简单地说，套接字就是网络进程的ID，网络通信归根到底是进程的通信，在网络中，每个节点有一个网络地址（即IP地址），两个进程通信时，首先要确定各自所在网络节点的网络地址，但是，网络地址只能确定进程所在的计算机，而一台计算机上可能同时有多个网络进程，还不能确定到底是其中的哪个进程，由此套接字中还要有其他的信息，那就是端口号（Port），在一台计算机中，一个端口一次只能分配给一个进程，即端口号与进程是一一对应的关系，所以，端口号和网络地址就能唯一地确定Internet中的一个网络进程。可以认为：套接字=网络地址+端口号系统调用一个Socket（）得到一个套接字描述符，然后就可以通过他进行网络通信了。
套接字有很多种类，最常用的就有两种；流式套接字和数据报套接字。在Linux中分别称之为"SOCK_STREAM"和"SOCK_DGRAM）"他们分别使用不同的协议，流式套接字使用TCP协议，数据报套接字使用UDP协议，本文所使用的是流式套接字协议。
网络通信原理在文件传输程序设计中的应用网络上的绝大多数通信采用的都是客户机/服务器机制（Client/Server），即服务器提供服务，客户是这些服务的使用者，服务器首先创建一个Socket，然后将该Socket与本地地址/端口号绑定（Bind（）），成功之后就在相应的Socket上监听（Listen（）） 。当Accept（）函数捕捉到一个连接服务（Connect（））请求时，接受并生成一个新的Socket,并通过这个新的Socket与客户端通信，客户端同样也要创建一个Socket，将该Socket与本地地址/端口号绑定，还需要指定服务器端的地址与端口号，随后向服务器端发出Connect（），请求被服务器端接受后，可以通过Socket与服务器端通信。
TCP是一种面向连接的、可靠的、双向的通信数据流，说他可靠，是因为他使用3段握手协议传输数据，并且在传输时采用"重传肯定确认"机制保证数据的正确发送：接收端收到的数据后要发出一个肯定确认，而发送端必须要能接受到这个肯定信号，否则就要将数据重发。在此原理基础之上，设计了基于Linux操作系统下TCP/IP编程实现文件传输的实例。我们采用客户机/服务器模式通信时，通信双方发送/接收数据的工作流程如图3所示。
文件传输就是基于客户机/服务器模型而设计的，客户机和服务器之间利用TCP建立连续，因文件传输是一个交互式会话系统，客户机每次执行文件传输，都需要与服务器建立控制连接和数据连接，其中控制连接负责传输控制信息、利用控制命令、客户机可以向服务器提出无限次的请求，客户机每次提出的请求，服务器与客户机建立一个数据连接，进行实际的数据传输，数据传输完毕后，对应的数据连接被清除，控制连接依然保持，等待客户机发出新的传输请求，直到客户机撤销控制连接，结束会话。
当进行文件传输时，首先向服务器发出连接请求，服务器验证身份后，与客户端建立连接，双方进入会话状态，这时只要客户端向服务器端发出数据连接请求，建立起数据连接后，双方就进入数据传输状态，数据传输完毕后，数据连接被撤销，如此循环反复，直到会话结束，从而实现将文件从服务器端传输至客户机端。
文件传输程序设计流程[5，客户端的TCP应用程序流程（1）先用Socket（）创建本地套接口，给服务器端套接口地址结构赋值。
（2）用Connect（）函数使本地套接口向服务器端套接口发出建立连接请求，经3次握手建立TCP连接。
（3）用Read（）函数读取所要接收的文件名以及存放在内存里的文件内容。
（4）用Open（）函数打开客户端新建立的目标文件，如果没有建立，该函数会自动生成目标文件，等待存放文件内容。
（5）最后用Write（）函数将读取的文件内容存放在新的目标文件中，以实现服务器端向客户端的文件传输。
（6）通信结束，用Close（）关闭套接口，停止接收文件。
服务器端的TCP应用程序流程（1）先用Open（）函数打开等待传输的可读文件；（2）用Socket（）创建套接口，并给套接口地址结构赋值；（3）用Bind（）函数绑定套接口；（4）用Listen（）函数在该套接口上监听请求；（5）用Accept（）函数接受请求，产生新的套接口及描述字，并与客户端连接；（6）用Lseek（）函数是为了在每次接受客户机连接时，将用于读的源文件指针移到文件头；（7）用Read（）函数读取一定长度的源文件数据；（8）最后用Write（）函数将读取的源文件数据存放在内存中，以便客户端读取；（9）传输完毕时，用Close（）关闭所有进程，结束文件传输。
结语Linux操作系统在网络应用方面具有很强的开发潜力，同时Linux也是可靠性、安全性非常高的系统，因此在基于TCP/IP网络通信的研究与开发中，通常选用Linux操作系统作为开发平台
linux系统网络编程主要是学什么？？要用到哪些概念和函数？？最好是举例说明，要详细些？
【热心相助】
您好！
linux系统网络编程主要是学习：
常用的各种命令语句，与功能、性能、可靠性等有关的操作语句
程序控制结构，顺序结构、选择结构、循环结构
过程、函数、表达式等使用
关于系统网络编程不是一两句话就能讲清楚的，不过我建议你去看下这本书 《unix环境高级编程》是一本经典书籍，在网上搜下就有。
进程和线程
多线程和多进程要学。socket套接字要学。TCP/UDP也要学。这些是基本肯定要学的吧，其余的就不知道你们研究多深了。用到的函数太多了- -！而且函数的参数也多的一笔，很难记的，有帮助手册了还好。