linux下socket编程（linux下socket如何传输一个目录以及目录下的子文件子目录）

本文目录

• linux下socket如何传输一个目录以及目录下的子文件子目录
• linux下socket编程中 bind(sockfd,(struct sockaddr *)(&server_addr),sizeof(struct sockaddr)) 怎么理解
• Linux下Socket编程 怎样实现客户端之间互相通信
• 请教linux下socket编程中send函数如何强制其将数据发出去
• linux下socket 网络编程(客户端向服务器端发送文件) 求源代码 大哥大姐帮帮忙 谢谢
• Windows Socket和Linux Socket编程的区别 ZZ
• Linux下socket编程的sockaddr_in结构体中的__SOCKADDR_COMMON (sin_);是什么意思
• Linux编程socket通信疑问
• 想问一个 关于linux下 socket编程的问题！ 请进
• linux下的 socket编程问题！

linux下socket如何传输一个目录以及目录下的子文件子目录

socket编程，需要一个服务器端和一个客户端
传输文件夹的话可以在服务器端进行发送在客户端进行接收
方法是，在指定端口建立侦听，比如8888，使用的协议可以是tcp/ip或者udp/ip
udp是种无链接不可靠的协议，建议传输文件还是使用tcp协议
客户端通过connect函数连接服务器端后就可进行数据传输
其实文件传输本质就是数据传输，我们在服务器端只需要使用opendir函数“打开”文件夹
再使用readdir函数遍历文件夹即可，将所有读到的文件名进行判断，比如判断该文件是否为文件夹，或者是否会特殊文件，比如软链接，socket文件，管道文件等等，如果是文件夹则进行该文件夹进行递归（即进入该文件夹后施行前面相同的方法，以此类推下去，直到读取完所有的文件夹），并将该文件夹名称发送给客户端，客户端接收到该文件夹名称后使用mkdir函数创建一个文件夹，如果为一般文件将该文件名和所在目录发送到客户端，客户端创建该文件（如果是多级文件夹则客户端则进入文件夹）读取该文件（fopen或者open），可以一边读取文件内容一边将读取的内容发送给客户端，客户端则将接收到的内容写入到文件即可
这里需要注意的就是服务器端与客户端需要规划好一定的规则，也就是需要建立一个简单的服务器与客户端通信的协议
比如最简单的我们使用 文件类型：文件名 来表明传输的数据的意义
服务器端在检查文件夹内的文件时通过不同的文件类型来制定不同的标签，客户端通过检测这些标签来确定下一步的操作
比如服务器检测到一个文件夹则会发送 文件夹：该文件夹的名称
客户端在接收到该数据后进行解析，解析到冒号前的文件类型为文件夹则创建一个冒号后的文件夹名称（这里文件夹名称包括多级目录，我们也可以设置的更完善点，比如 文件类型：文件夹：文件夹：文件夹，最后一个文件夹名称则为客户端需要创建的文件夹，前面的则是该文件夹所在的绝对路径）
有了这种简明的协议就可以更好地完成socket文件夹复制工作

linux下socket编程中 bind(sockfd,(struct sockaddr *)(&server_addr),sizeof(struct sockaddr)) 怎么理解

(struct sockaddr *)(&server_addr)这个是一个强制类型转换，就是将结构体&server_addr强制转换成struct sockaddr *类型。这个是c语言范畴的东西。
因为我们只能创建和填充sockaddr_in和sockaddr_in6的结构体和里面的字段，但是很多socket参数只接受sockaddr类型的结构体，所以在这里要强制转换一下，就我记得connect()函数里也会转换一下。

Linux下Socket编程 怎样实现客户端之间互相通信

1. 网络的Socket数据传输是一种特殊的I/O，Socket也是一种文件描述符。Socket也具有一个类似于打开文件的函数调用Socket()，该函数返回一个整型的Socket描述符，随后的连接建立、数据传输等操作都是通过该Socket实现的。

2. 下面用Socket实现一个windows下的c语言socket通信例子，这里我们客户端传递一个字符串，服务器端进行接收。

【服务器端】
#include "stdafx.h"
#include 《stdio.h》
#include 《winsock2.h》
#include 《winsock2.h》
#define SERVER_PORT 5208 //侦听端口
void main()
{
    WORD wVersionRequested;
    WSADATA wsaData;
    int ret, nLeft, length;
    SOCKET sListen, sServer; //侦听套接字，连接套接字
    struct sockaddr_in saServer, saClient; //地址信息   
    char *ptr;//用于遍历信息的指针   
    //WinSock初始化
    wVersionRequested=MAKEWORD(2, 2); //希望使用的WinSock DLL 的版本
    ret=WSAStartup(wVersionRequested, &wsaData);
    if(ret!=0)
    {
        printf("WSAStartup() failed!\n");
        return;
    }
    //创建Socket,使用TCP协议
    sListen=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (sListen == INVALID_SOCKET)
    {
        WSACleanup();
        printf("socket() faild!\n");
        return;
    }
    //构建本地地址信息
    saServer.sin_family = AF_INET; //地址家族
    saServer.sin_port = htons(SERVER_PORT); //注意转化为网络字节序
    saServer.sin_addr.S_un.S_addr = htonl(INADDR_ANY); //使用INADDR_ANY 指示任意地址
  
    //绑定
    ret = bind(sListen, (struct sockaddr *)&saServer, sizeof(saServer));
    if (ret == SOCKET_ERROR)
    {
        printf("bind() faild! code:%d\n", WSAGetLastError());
        closesocket(sListen); //关闭套接字
        WSACleanup();
        return;
    }
  
    //侦听连接请求
    ret = listen(sListen, 5);
    if (ret == SOCKET_ERROR)
    {
        printf("listen() faild! code:%d\n", WSAGetLastError());
        closesocket(sListen); //关闭套接字
        return;
    }
  
    printf("Waiting for client connecting!\n");
    printf("Tips: Ctrl+c to quit!\n");
    //阻塞等待接受客户端连接
 while(1)//循环监听客户端，永远不停止，所以，在本项目中，我们没有心跳包。
 {
  length = sizeof(saClient);
  sServer = accept(sListen, (struct sockaddr *)&saClient, &length);
  if (sServer == INVALID_SOCKET)
  {
   printf("accept() faild! code:%d\n", WSAGetLastError());
   closesocket(sListen); //关闭套接字
   WSACleanup();
   return;
  }       
  char receiveMessage;
   nLeft = sizeof(receiveMessage);
  ptr = (char *)&receiveMessage;
  while(nLeft》0)
  {
   //接收数据
   ret = recv(sServer, ptr, 5000, 0);
   if (ret == SOCKET_ERROR)
   {
    printf("recv() failed!\n");
    return;
   }
   if (ret == 0) //客户端已经关闭连接
   {
    printf("Client has closed the connection\n");
    break;
   }
   nLeft -= ret;
   ptr += ret;
  }  
    printf("receive message:%s\n", receiveMessage);//打印我们接收到的消息。
  
 }
  //  closesocket(sListen);
  //  closesocket(sServer);
  //  WSACleanup();
}
【客户端】
#include "stdafx.h"
#include 《stdio.h》
#include 《stdlib.h》
#include 《winsock2.h》
#define SERVER_PORT 5208 //侦听端口
void main()
{
   WORD wVersionRequested;
   WSADATA wsaData;
   int ret;
   SOCKET sClient; //连接套接字
   struct sockaddr_in saServer; //地址信息
   char *ptr;
   BOOL fSuccess = TRUE;
   //WinSock初始化
   wVersionRequested = MAKEWORD(2, 2); //希望使用的WinSock DLL的版本
   ret = WSAStartup(wVersionRequested, &wsaData);
   if(ret!=0)
   {
        printf("WSAStartup() failed!\n");
        return;
   }
   //确认WinSock DLL支持版本2.2
   if(LOBYTE(wsaData.wVersion)!=2 || HIBYTE(wsaData.wVersion)!=2)
   {
        WSACleanup();
        printf("Invalid WinSock version!\n");
        return;
   }
   //创建Socket,使用TCP协议
   sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
   if (sClient == INVALID_SOCKET)
   {
        WSACleanup();
        printf("socket() failed!\n");
        return;
   }
   //构建服务器地址信息
   saServer.sin_family = AF_INET; //地址家族
   saServer.sin_port = htons(SERVER_PORT); //注意转化为网络节序
   saServer.sin_addr.S_un.S_addr = inet_addr("192.168.1.127");
   //连接服务器
   ret = connect(sClient, (struct sockaddr *)&saServer, sizeof(saServer));
   if (ret == SOCKET_ERROR)
   {
        printf("connect() failed!\n");
        closesocket(sClient); //关闭套接字
        WSACleanup();
        return;
   }
  
  
   char sendMessage="hello this is client message!";
   ret = send (sClient, (char *)&sendMessage, sizeof(sendMessage), 0);
   if (ret == SOCKET_ERROR)
   {
        printf("send() failed!\n");
   }
   else
        printf("client info has been sent!");
   closesocket(sClient); //关闭套接字
   WSACleanup();
}

请教linux下socket编程中send函数如何强制其将数据发出去

在多线程编程中其中使用一个线程来accept要连接的客户端。同时在接受client的请求之后新建一个线程来进行具体的操作。其操作包括向client端发送一定字节的数据，使用send()函数来进行操作。如果在发送过程中出现任何一个client端的断线，则整个程序都会退出。
ssize_t send(int sockfd, const void *buff, size_t nbytes, int flags);
关于Linux命令的介绍，看看《linux就该这么学》，具体关于这一章地址3w(dot)linuxprobe/chapter-02(dot)html
上面为send函数原型，在通常的使用中flags参数一般设置为0.此时如果客户端断开，继续往里边写数据的话，会引发一个信号SIGPIPE,此信号会引发线程的退出、
解决的方法：1）可以将flags参数设置为MSG_NOSIGNAL。2）设置SIG_IGN信号处理函数。

linux下socket 网络编程(客户端向服务器端发送文件) 求源代码 大哥大姐帮帮忙 谢谢

server:
#include 《stdio.h》
#include 《errno.h》
#include 《unistd.h》
#include 《signal.h》
#include 《stdlib.h》
#include 《sys/types.h》
#include 《sys/socket.h》
#include 《arpa/inet.h》
#include 《netinet/in.h》
#include 《syslog.h》
#include 《sys/time.h》
#include 《string.h》
#include 《fcntl.h》
#include 《sys/wait.h》
#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;
char send_str;
char filepath = {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\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, "\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;
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 = {0};
char FileName = {0};
char path = {0};
MyHandleBuff(buff, str, FileName, path);
if (recvbytes 》 0)
{
nret = SendFileToServ(path, FileName, str);
printf("nret\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 《stdio.h》
#include 《errno.h》
#include 《unistd.h》
#include 《signal.h》
#include 《stdlib.h》
#include 《sys/types.h》
#include 《sys/socket.h》
#include 《arpa/inet.h》
#include 《netinet/in.h》
#include 《syslog.h》
#include 《sys/time.h》
#include 《string.h》
#include 《fcntl.h》
#include 《sys/wait.h》
#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, "\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;
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= {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\n", ret);
if (ret != 0)
{
write(client_fd, Eptr, strlen(Eptr));
}
else
{
write(client_fd, Sptr, strlen(Sptr));
}
close(client_fd);
}
}
以前写的：内容忘记了。不是很复杂你可以自己看！

Windows Socket和Linux Socket编程的区别 ZZ

　　下面大概分几个方面进行罗列：
　　Linux要包含
　　
　　#include
《sys/socket.h》
　　#include
《netinet/in.h》
　　#include
《netdb.h》
　　#include
《arpa/inet.h》
　　等头文件，而windows下则是包含
　　
　　#include
《winsock.h》
　　。
　　Linux中socket为整形，Windows中为一个SOCKET。
　　Linux中关闭socket为close，Windows中为closesocket。
　　Linux中有变量socklen_t，Windows中直接为int。
　　因为linux中的socket与普通的fd一样，所以可以在TCP的socket中，发送与接收数据时，直接使用read和write。而windows只能使用recv和send。
　　设置socet选项，比如设置socket为非阻塞的。Linux下为
　　
　　flag
=
fcntl
(fd,
F_GETFL);
　　fcntl
(fd,
F_SETFL,
flag
|
O_NONBLOCK);
　　，Windows下为
　　
　　flag
=
1;
　　ioctlsocket
(fd,
FIONBIO,
(unsigned
long
*)
&flag);
　　。
　　当非阻塞socket的TCP连接正在进行时，Linux的错误号为EINPROGRESS，Windows的错误号为WSAEWOULDBLOCK。

Linux下socket编程的sockaddr_in结构体中的__SOCKADDR_COMMON (sin_);是什么意思

__SOCKADDR_COMMON
();是宏定义的意思，括号里面是它的参数，这个宏定义表示的是tcp/ip协议的版本是，ipv4还是ipv6的意思，最后的那个unsigned
char
sin_zero的大小为什么做减法呢，是为了保证这个结构提到大小和另一个套接字地址的结构体struct
sockaddr的大小一致。这么说不知道你能不能不能理解，第一个参数在实际使的时候一般是个常数。
再看看别人怎么说的。

Linux编程socket通信疑问

什么是Socket　　
Socket接口是TCP/IP网络的API，Socket接口定义了许多函数或例程，程序员可以用它们来开发TCP/IP网络上的应用程序。要学Internet上的TCP/IP网络编程，必须理解Socket接口。　
　
Socket接口设计者......
答案就在这里：linux
socket
通信编程
----------------------Hi，地球人，我是问答机器人小S，上面的内容就是我狂拽酷炫叼炸天的答案，除了赞同，你还有别的选择吗？

想问一个 关于linux下 socket编程的问题！ 请进

1、 accept函数中，第三个参数原型是 socklen_t的，这是个什么啊？ 编译的时候总是 说 它和int 的转换无效！ 应该怎么修改？
a.accept的函数原型为int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);最后一个参数是socklen_t类型，没记错的话，他是unsigned int类型。所以会有gcc会warning（g++则报错，g++更严格）
2、编译的时候 命令行输入的是：
./TCPServer (服务器IP) （端口号）
我想问的是，这个 服务器IP和 端口号 在程序里面是怎么体现出来的？
是不是 那个 if(argc!=2) 决定的啊？ 也就是命令行必须 输出2个字符串。
如果输出 三个字符串（包括端口号） 能行么？ 哪位高手帮帮我啊！
a.服务器的IP是写死在程序里的，这句，
server_addr.sin_addr.s_addr=htonl(INADDR_ANY);INADDR_ANY表示让协议栈自己选IP地址(针对多IP的情况)；端口体现在这句 server_addr.sin_port=htons(portnumber);程序要求你输入两个字符串，其中第一个为程序名，第二个为端口号。比如你编译出来的程序叫server,则命令为server 8888,就可以执行了。注意这里的argc等于几表示连程序名称在内总共有几个字符串。
4、 最后的 close（）函数 作用范围不明！
因为你调用了socket函数打开了一个描述字sockfd,所以这里要把他关闭。
newfd是你accept返回的描述字，前面已经关了，这两个是不一样的。sockfd用来监听，newfd用来与建立连接的对端通讯。
另外，你露了头文件，所以warning
#include 《stdlib.h》
#include 《stdio.h》
#include 《errno.h》
#include 《string.h》
#include 《netdb.h》
#include 《sys/types.h》
#include 《netinet/in.h》
#include 《sys/socket.h》
#define WAITBUF 10
#include 《unistd.h》
#include 《arpa/inet.h》
int main(int argc, char *argv)
{
int sockfd,new_fd;
struct sockaddr_in server_addr;
struct sockaddr_in client_addr;
socklen_t sin_size;
int portnumber;
char hello="Hello! Socket communication world!\n";
if(argc!=2)
{
fprintf(stderr,"Usage:%s portnumber\a\n",argv);
exit(1);
}
/*端口号不对，退出*/
if((portnumber=atoi(argv))《0)
{
fprintf(stderr,"Usage:%s portnumber\a\n",argv);
exit(1);
}
/*服务器端开始建立socket描述符*/
if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1)
{
fprintf(stderr,"Socket error:%s\n\a",strerror(errno));
exit(1);
}
/*服务器端填充 sockaddr结构*/
bzero(&server_addr,sizeof(struct sockaddr_in));
server_addr.sin_family=AF_INET;
/*自动填充主机IP*/
server_addr.sin_addr.s_addr=htonl(INADDR_ANY);
server_addr.sin_port=htons(portnumber);

/*捆绑sockfd描述符*/
if(bind(sockfd,(struct sockaddr *)(&server_addr),sizeof(struct sockaddr))==-1)
{
fprintf(stderr,"Bind error:%s\n\a",strerror(errno));
exit(1);
}

/*监听sockfd描述符*/
if(listen(sockfd, WAITBUF)==-1)
{
fprintf(stderr,"Listen error:%s\n\a",strerror(errno));
exit(1);
}
while(1)
{
/*服务器阻塞，直到客户程序建立连接*/
sin_size=sizeof(struct sockaddr_in);
if((new_fd=accept(sockfd,(struct sockaddr *)(&client_addr),&sin_size))==-1)
{
fprintf(stderr,"Accept error:%s\n\a",strerror(errno));
exit(1);
}
/*可以在这里加上自己的处理函数*/
fprintf(stderr,"Server get connection from %s\n",
inet_ntoa(client_addr.sin_addr));
if(send(new_fd,hello,strlen(hello),0)==-1)
{
fprintf(stderr,"Write Error:%s\n",strerror(errno));
exit(1);
}
/*这个通信已经结束*/
close(new_fd);
/*循环下一个*/
}
close(sockfd);
exit(0);
}

linux下的 socket编程问题！

第一个问题:
对，是那样的，用open打开文件，用read读取文件，在发送给对方，接收方接收到后，写入文件就可以了。不过在这个过程中最好别用字符串函数，除非你很熟悉。
第二个问题
首先你得去搞清楚什么是线程，什么是进程，fork出来的叫进程，pthread_create出来的才叫线程。服务器有很多种模型(多进程，多线程，select,epoll模型,这个我的blog上有,famdestiny.cublog.cn)，不一定要用多进程。
给你写了个代码，自己先看看:
注意，在自己的目录下创建一个叫pserverb的文件，程序会把这个文件复制成test文件。你可以自己根据需要改改
server:
#include 《stdio.h》
#include 《sys/socket.h》
#include 《netinet/in.h》
#include 《errno.h》
#include 《signal.h》
#include 《sys/wait.h》
#include 《sys/types.h》
#include 《string.h》
#include 《stdlib.h》
#include 《sys/stat.h》
#include 《fcntl.h》
#include 《unistd.h》
#define SERV_PORT 5358
#define MAX_CONN 10
#define BUF_LEN 1024
void str_echo(FILE *fp, int sockfd){
ssize_t nread;
int file_fd;
char buf = {0};
file_fd = open("test", O_WRONLY | O_TRUNC | O_CREAT, 0755);
while(1) {
bzero(buf, BUF_LEN);
if((nread = read(sockfd, buf, BUF_LEN)) == -1) {
if(errno == EINTR) {
continue;
}
else {
printf("readn error: %s\n", strerror(errno));
continue;
}
}
else if (nread == 0) {
break;
}
else {
printf("%s\n", buf);
write(file_fd, buf, nread);
}
}
close(file_fd);
}
void sig_chld(int sig){
pid_t pid;
int state;
while((pid = waitpid(-1, &state, WNOHANG)) 》 0){
printf("child process %d exited.", pid);
}
return;
}
int main(int argc, char **argv)
{
int listenfd, connfd;
socklen_t cliaddrlen;
pid_t childpid;
struct sockaddr_in servaddr, cliaddr;
if((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
printf("socket error: %s\n", strerror(errno));
return 0;
}
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);
if(bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1){
printf("bind error: %s\n", strerror(errno));
return 0;
}
if(listen(listenfd, MAX_CONN) == -1){
printf("listen error: %s\n", strerror(errno));
return 0;
}
signal(SIGCHLD, sig_chld);
while(1){
cliaddrlen = sizeof(cliaddr);
if((connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddrlen)) == -1){
if(errno == EINTR){
continue;
}
else{
printf("accept error: %s\n", strerror(errno));
continue;
}
}
if((childpid = fork()) == 0){
close(listenfd);
str_echo(stdin, connfd);
exit(0);
}
else if(childpid 》 0){
close(connfd);
}
else{
printf("fork error!\n");
continue;
}
}
}
client:
#include 《stdio.h》
#include 《unistd.h》
#include 《errno.h》
#include 《sys/socket.h》
#include 《netinet/in.h》
#include 《arpa/inet.h》
#include 《string.h》
#include 《sys/stat.h》
#include 《fcntl.h》
#include 《stdlib.h》
#define SERV_ADDR "127.0.0.1"
#define SERV_PORT 5358
#define BUF_LEN 1024
void str_cli(char *path, int sockfd)
{
char sendbuf = {0};
int fd, n;
if((fd = open("./pserverb", O_RDONLY)) == -1){
printf("%s\n", strerror(errno));
exit(0);
}
while((n = read(fd, sendbuf, BUF_LEN)) != 0) {
if(n 《 0){
printf("%s\n", strerror(errno));
exit(0);
}
write(sockfd, sendbuf, n);
bzero(sendbuf, BUF_LEN);
}
close(fd);
return;
}
int main(int argc, char **argv)
{
int fd;
struct sockaddr_in servaddr;
fd = socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = inet_addr(SERV_ADDR);
servaddr.sin_port = htons(SERV_PORT);
if (connect(fd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1) {
printf("connect error: %s\n", strerror(errno));
return 0;
}
str_cli(argv, fd);
return 0;
}