linuxsend发送大数据

㈠ linux下socket的通信问题，如何让SEND函数立刻发送数据

struct sockaddr_un address; // 这是24行
你写错字了，不是un，是in
正确写法：
struct sockaddr_in address;

㈡ linux下C语言socket编程双机互发数据

这个问题很好办啦，服务器接受一个连接请求，然后开一个线程或者进程都可以，再在线程或者进程里面采用其他技术实现同时收发(比如I/O复用，比如非阻塞I/O)。客户端也可以采用I/O复用。

推荐资料的话，《unix网络编程》这本书很好，公认的经典，当教科书用，这本书里有你想要的所有内容。

ps:你基础太差，多补补吧，别想一下吃个胖子。

另外我这里正好有个例子满足你的要求,贴给你，自己写的，不是网上找的,用的是多进程加I/O复用技术:

server端:
/****************************************************************
**
**
**
****************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <errno.h>
#include <string.h>
#include <signal.h>
#include <sys/wait.h>
#include <sys/select.h>
#include <sys/time.h>
#include <unistd.h>

#define BUFLEN 1024
#define MAX(a,b) ((a)>(b)?(a):(b))

typedef void Sigfunc (int);

void str_echo(FILE *,int);
//Sigfunc *signal(int, Sigfunc *);

int main(int argc,char **argv)
{
int connfd,listenfd;
pid_t childpid;
socklen_t clilen;
struct sockaddr_in cliaddr,servaddr;
void sig_chld(int);

listenfd = socket(AF_INET, SOCK_STREAM, 0);

memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(5358);

bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
listen(listenfd,8);

signal(SIGCHLD,sig_chld);

while(1)
{
clilen = sizeof(cliaddr);
if((connfd = accept(listenfd,(struct sockaddr*)&cliaddr,&clilen)) < 0)
{
if(errno == EINTR)
{
fputs("accept error: EINTR\n",stdout);
continue;
}
else
{
fputs("accept error..\n",stdout);
}
}

if((childpid = fork()) == 0)
{
close(listenfd);
str_echo(stdin,connfd);
exit(0);
}
close(connfd);
}
}

void str_echo(FILE *fp,int sockfd)
{
int n = 0;
char sendbuf[BUFLEN] = { 0 },recvbuf[BUFLEN] = { 0 };
int maxfdp;
fd_set rset;

FD_ZERO(&rset);

while(1)
{
FD_SET(fileno(fp),&rset);
FD_SET(sockfd, &rset);
maxfdp = MAX(fileno(fp),sockfd)+1;

select(maxfdp, &rset ,NULL, NULL, NULL);

if(FD_ISSET(sockfd, &rset))
{
if(n = read(sockfd, recvbuf, BUFLEN) == 0)
{
return;
}
if(n == -1)
{
break;
}
printf("%s\n",recvbuf);
memset(recvbuf,0,BUFLEN);
}
if(FD_ISSET(fileno(fp),&rset))
{
scanf("%s",sendbuf);
write(sockfd, sendbuf,strlen(sendbuf));
}
}
}

void sig_chld (int signo)
{
pid_t pid;
int stat;

while ((pid = waitpid(-1,&stat, WNOHANG)) > 0)
{
printf("child %d terminated\n",pid);
}
return;
}

client端:
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/select.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>

#define MAX(a,b) (a)>(b)?(a):(b)

int main()
{
int s,connectReturn, maxfd;
fd_set rset;
char sendbuf[1024] = {0};
char recvbuf[1024] = {0};
long port=5358;
s=socket(PF_INET,SOCK_STREAM,0);

struct sockaddr_in sa;
sa.sin_family=AF_INET;
sa.sin_addr.s_addr=inet_addr("127.0.0.1");
sa.sin_port=htons(port);
connectReturn=connect(s,(struct sockaddr *)&sa,sizeof(sa));
printf("%d\n",connectReturn);
FD_ZERO(&rset);
while(1)
{
FD_SET(fileno(stdin), &rset);
FD_SET(s, &rset);
maxfd=MAX(fileno(stdin), s) + 1;

select(maxfd, &rset, NULL, NULL, NULL);
if(FD_ISSET(fileno(stdin), &rset))
{
scanf("%s",sendbuf);
send(s,sendbuf,strlen(sendbuf),0);
bzero(sendbuf, 1024);
}
else if(FD_ISSET(s, &rset))
{
memset(recvbuf,0,1024);
recv(s,recvbuf,1024,0);
printf("remote: %s\n",recvbuf);
}
}
return 0;
}

㈢ linux 网络编程 send 做了什么操作

send解析
sockfd：指定发送端套接字描述符。
buff： 存放要发送数据的缓冲区
nbytes: 实际要改善的数据的字节数
flags： 一般设置为0
1) send先比较发送数据的长度nbytes和套接字sockfd的发送缓冲区的长度，如果nbytes > 套接字sockfd的发送缓冲区的长度, 该函数返回SOCKET_ERROR;
2) 如果nbtyes <= 套接字sockfd的发送缓冲区的长度，那么send先检查协议是否正在发送sockfd的发送缓冲区中的数据，如果是就等待协议把数据发送完，如果协议还没有开始发送sockfd的发送缓冲区中的数据或者sockfd的发送缓冲区中没有数据，那么send就比较sockfd的发送缓冲区的剩余空间和nbytes
3) 如果 nbytes > 套接字sockfd的发送缓冲区剩余空间的长度，send就一起等待协议把套接字sockfd的发送缓冲区中的数据发送完
4) 如果 nbytes < 套接字sockfd的发送缓冲区剩余空间大小，send就仅仅把buf中的数据到剩余空间里(注意并不是send把套接字sockfd的发送缓冲区中的数据传到连接的另一端的，而是协议传送的，send仅仅是把buf中的数据到套接字sockfd的发送缓冲区的剩余空间里)。
5) 如果send函数成功，就返回实际的字节数，如果send在数据时出现错误，那么send就返回SOCKET_ERROR; 如果在等待协议传送数据时网络断开，send函数也返回SOCKET_ERROR。
6) send函数把buff中的数据成功到sockfd的改善缓冲区的剩余空间后它就返回了，但是此时这些数据并不一定马上被传到连接的另一端。如果协议在后续的传送过程中出现网络错误的话，那么下一个socket函数就会返回SOCKET_ERROR。（每一个除send的socket函数在执行的最开始总要先等待套接字的发送缓冲区中的数据被协议传递完毕才能继续，如果在等待时出现网络错误那么该socket函数就返回SOCKET_ERROR）
7) 在unix系统下，如果send在等待协议传送数据时网络断开，调用send的进程会接收到一个SIGPIPE信号，进程对该信号的处理是进程终止。

㈣ linux send 最大可以发送多少

最大可以发送800M的
Linux系统渗嫌调用之send/sendto/sendmsg函数解析顷洞功能描述:发丛乎手送消息。

㈤ send的Linux C 函数

经套接字传送消息
相关函数
sendto,sendmsg,recv,recvfrom,recvmsg,socket
表头文件
#include < sys/socket.h >
定义函数
ssize_t send (int s,const void *msg,size_t len,int flags);
参数说明
第一个参数指定发送端套接字描述符；
第二个参数指明一个存放应用程式要发送数据的缓冲区；
第三个参数指明实际要发送的数据的字符数；
第四个参数一般置0。
函数说明
send() 用来将数据由指定的 socket 传给对方主机。使用 send 时套接字必须已经连接。send 不包含传送失败的提示信息，如果检测到本地错误将返回-1。因此，如果send 成功返回，并不必然表示连接另一端的进程接收数据。所保证的仅是当send 成功返回时，数据已经无错误地发送到网络上。
对于支持为报文设限的协议，如果单个报文超过协议所支持的最大尺寸，send 失败并将 errno 设为 EMSGSIZE ；对于字节流协议，send 会阻塞直到整个数据被传输。
flags 参数有如下的选择：
MSG_DONTROUTE 勿将数据路由出本地网络
MSG_DONTWAIT 允许非阻塞操作（等价于使用O_NONBLOCK）
MSG_EOR 如果协议支持，此为记录结束
MSG_OOB 如果协议支持，发送带外数据
MSG_NOSIGNAL 禁止向系统发送异常信息
返回值
成功则返回实际传送出去的字符数，失败返回－1，错误原因存于errno 中。
错误代码
EBADF 参数 s 非法的 socket 处理代码。
EFAULT 参数中有一指针指向无法存取的内存空间。
WNOTSOCK 参数 s 为一文件描述词，非 socket。
EINTR 被信号所中断。
EAGAIN 此动作会令进程阻断，但参数 s 的 socket 为不可阻断的。
ENOBUFS 系统的缓冲内存不足。
EINVAL 传给系统调用的参数不正确。

㈥ 请教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下send命令是干什么用的

功能描述：
发送消息，send只可用于基于连接的套接字，send 和 write唯一的不同点是标志的存在，当标志为0时，send等同于write。sendto 和 sendmsg既可用于无连接的套接字，也可用于基于连接的套接字。除了套接字设置为非阻塞模式，调用将会阻塞直到数据被发送完。
参数：
sock：索引将要从其发送数据的套接字。
buf：指向将要发送数据的缓冲区。
len：以上缓冲区的长度。
flags：是以下零个或者多个标志的组合体，可通过or操作连在一起
MSG_DONTROUTE：不要使用网关来发送封包，只发送到直接联网的主机。这个标志主要用于诊断或者路由程序。
MSG_DONTWAIT：操春唤作不会被阻塞。
MSG_EOR：终止一个记录。
MSG_MORE：调用者有更多的数据需要发送。
MSG_NOSIGNAL：当告胡另一端终止连接时，请求在基于流的错误套袜森拦接字上不要发送SIGPIPE信号。
MSG_OOB：发送out-of-band数据(需要优先处理的数据)，同时现行协议必须支持此种操作。
to：指向存放接收端地址的区域，可以为NULL。
tolen：以上内存区的长度，可以为0。

㈧ 大数据开发工程师要掌握哪些技术

1. Java编程技术

Java编程技术是大数据学习的基础塌并，Java是一种强类型语言，拥有极高的跨平台能力，可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等，是大数据工程师最喜欢的编程工具，因此，想学好大数据，掌握Java基础是必不陵亮可少的。

2.Linux命令

对于大数据开发通常是在Linux环境下进行的，相比Linux操作系统，Windows操作系统是封闭的操作系统，开源的大数据软件很受限制，因此，想从事大数据开发相关工作，还需掌握Linux基础操作命令。

3. Hadoop

Hadoop是大数据开发的重要框架，其核心是HDFS和MapRece，HDFS为海量的数据提供了存储，MapRece为海量的数据提供了计算，因此，需要重点掌握，除此之外，还需要掌握Hadoop集群、Hadoop集群管理、YARN以及Hadoop高级管理等相关技术与操作!

4. Hive

Hive是基于Hadoop的一个数据仓库工具，可以将结构化的数据文件映射为一张数据库表，并提供简单的sql查询功能，可以将sql语句转换为MapRece任务进行运行，十分适合数据仓库的统尺衫宽计分析。对于Hive需掌握其安装、应用及高级操作等。

5. Avro与Protobuf

Avro与Protobuf均是数据序列化系统，可以提供丰富的数据结构类型，十分适合做数据存储，还可进行不同语言之间相互通信的数据交换格式，学习大数据，需掌握其具体用法。

6.ZooKeeper

ZooKeeper是Hadoop和Hbase的重要组件，是一个为分布式应用提供一致性服务的软件，提供的功能包括：配置维护、域名服务、分布式同步、组件服务等，在大数据开发中要掌握ZooKeeper的常用命令及功能的实现方法。

关于大数据开发工程师要掌握哪些技术，小编就和您分享到这里了。

㈨ linux手册翻译——send(2)

send, sendto, sendmsg - send a message on a socket

系统调用 send()、sendto() 和 sendmsg() 用于将消息传输到另一个套接字。

仅当套接字处于连接状态时才可以使用 send() 调用（以便知道预期的接收者， 也就是说send()仅仅用于数据流类型的数据发送 ，对于TCP，服务端和客户端都可以使用send/recv；但是对于UDP，只能是客户端使用send/recv，服务端只能使用sendto/recvfrom，因为客户端是进行了connect操作知道要发送和接受的地址）。send() 和 write(2) 之间的唯一渗衡区别是存在 flags 参数。此外，
send(sockfd, buf, len, flags);
等价于
sendto(sockfd, buf, len, flags, NULL, 0);

参数 sockfd 是发送者套接字的文件描述符。

如果在连接模式的套接字(即套接字类型为SOCK_STREAM、SOCK_SEQPACKET)上使用 sendto()，则参数 dest_addr 和 addrlen 将被忽略(当它们不是NULL和0时可能返回错误EISCONN)，若套接字没有实际连接(还没有三次握手建立连接)将返回错误ENOTCONN。 否则，目标地址由 dest_addr 给出， addrlen 指定其大小。 对于 sendmsg()，目标地址由 msg.msg_name 给出， msg.msg_namelen 指定其大小。

对于 send() 和 sendto()，消息位于 buf 中，长度为 len 。 对于sendmsg()，消息存放于 msg.msg_iov 元素指向 数组数据区 (见下)中。 sendmsg() 调用还允许发送辅助数据（也称为控制信息） 。

如果消息太长而无法通过底层协议原子传递( too long to pass atomically through the underlying protocol )，则返回错误 EMSGSIZE，并且不会传输消息。

No indication of failure to deliver is implicit in a send(). Locally detected errors are indicated by a return value of -1.

当消息轿陵不适合套接字的发送缓冲区时，send() 通常会阻塞，除非套接字已置于非阻塞 I/O 模式。 在这种情况下，在非阻塞模式下它会失败并显示错误 EAGAIN 或 EWOULDBLOCK。 select(2) 调用可用于确定何时可以发送更多数据 。

上面的的描述还是很笼统的，以TCP为例，按我的理解，我认为只要发送缓冲区有空闲位置，且此时协议栈没有向网络发送数据，那么就可以写入，对于阻塞模式，直到所有数据写入到缓冲区，就会返回，否则一直阻塞，对于非阻塞模式，是有一个超时时间的，这个由 SO_SNDTIMEO 选项控制，详细见 socket(7) ，如果当前有空闲位置可以发即当前可写入，那么就写入到缓冲区，知道超时之前写入多少算多少，然后返回成功写入的字节数，如果超时时任何数据都没写出去，或者当前就是闭喊戚不可写入，那么返回-1 ，并设置errno为 EAGAIN 或 EWOULDBLOCK。

The flags argument is the bitwise OR of zero or more of the following flags.

sendmsg() 使用的 msghdr 结构的定义如下：

对于未连接的套接字 msg_name 指定数据报的目标地址，它指向一个包含地址的缓冲区； msg_namelen 字段应设置为地址的大小。 对于连接的套接字，这些字段应分别指定为 NULL 和 0。 这里的未连接指的是数据报协议，连接指的是数据流协议

The msg_iov and msg_iovlen fields specify scatter-gather locations, as for writev(2).
msg_iov是一个buffer数组:

使用 msg_control 和 msg_controllen 成员发送控制信息（辅助数据）。 内核可以处理的每个套接字最大控制缓冲区长度由 /proc/sys/net/core/optmem_max 中的值限制； 见 socket(7) 。 有关在各种套接字域中使用辅助数据的更多信息，请参阅 unix(7) 和 ip(7)。

msg_flags 字段被忽略。

成功时，返回成功发送的字节数，这个字节数并不一定和我们的缓冲区大小相同 。 出错时，返回 -1，并设置 errno 以指示错误。

这些是套接字层生成的一些标准错误。 底层协议模块可能会产生和返回额外的错误； 请参阅它们各自的手册页。

4.4BSD, SVr4, POSIX.1-2001. These interfaces first appeared in 4.2BSD.

POSIX.1-2001 describes only the MSG_OOB and MSG_EOR flags. POSIX.1-2008 adds a specification of MSG_NOSIGNAL. The MSG_CONFIRM flag is a Linux extension.

根据 POSIX.1-2001，msghdr 结构的 msg_controllen 字段应该是 socklen_t 类型，而 msg_iovlen 字段应该是 int 类型，但是 glibc 目前将两者都视为 size_t。

有关可用于在单个调用中传输多个数据报的 Linux 特定系统调用的信息，请参阅 sendmmsg(2)。

Linux may return EPIPE instead of ENOTCONN.

getaddrinfo(3) 中显示了使用 send() 的示例。

㈩ socket linux c++ send（）函数

给你一个代码,linux下编译运行即可，做了简单的注释，client.c如下：

send()函数在client.c末尾

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>

#defineMAXLINE4096//发送接受信息长度
#definePORT6666//端口

intmain(intargc,char**argv)
{
intsockfd,n;
charrecvline[MAXLINE],sendline[MAXLINE];
structsockaddr_inservaddr;

if(argc!=2){
printf("usage:./client<ipaddress>
");//使用方法
exit(0);
}

if((sockfd=socket(AF_INET,SOCK_STREAM,0))<0){//创建套接字，并未连接
printf("createsocketerror:%s(errno:%d)
",strerror(errno),errno);
exit(0);
}
	

//memset(结构体地址，清零，要清零的长度);清零结构体servaddr，将结构体数据全部设置为0
	//同bzero(结构体地址，要清理的长度);默认清零
memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family=AF_INET;//sa_family是通信类型，最常用的值是"AF_INET"
servaddr.sin_port=htons(PORT);//端口号
	
	//servaddr.sin_addr.s_addr=inet_addr(argv[1]);//服务器IP,如下功能相同
	if(inet_pton(AF_INET,argv[1],&servaddr.sin_addr)<=0){
printf("inet_ptonerrorfor%s
",argv[1]);
exit(0);
}

//连接服务器
if(connect(sockfd,(structsockaddr*)&servaddr,sizeof(servaddr))<0){
printf("connecterror:%s(errno:%d)
",strerror(errno),errno);
exit(0);
}

printf("sendmsgtoserver:
");
fgets(sendline,MAXLINE,stdin);//输入向服务器发送的信息
	
if(send(sockfd,sendline,strlen(sendline),0)<0)//向服务器发送信息
{
printf("sendmsgerror:%s(errno:%d)
",strerror(errno),errno);
exit(0);
}

close(sockfd);//关闭套接字
exit(0);
}

服务器程序：server.c如下：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>

#defineMAXLINE4096
#definePORT6666

intmain(intargc,char**argv)
{
intlistenfd,connfd;
structsockaddr_inservaddr;
charbuff[MAXLINE];
intn;

if((listenfd=socket(AF_INET,SOCK_STREAM,0))==-1){//创建套接字
printf("createsocketerror:%s(errno:%d)
",strerror(errno),errno);
exit(0);
}

memset(&servaddr,0,sizeof(servaddr));//结构体清零
servaddr.sin_family=AF_INET;//sa_family是通信类型，最常用的值是"AF_INET"
servaddr.sin_addr.s_addr=htonl(INADDR_ANY);//指定接受任何连接
servaddr.sin_port=htons(PORT);//监听端口

	//给套接口绑定地址
if(bind(listenfd,(structsockaddr*)&servaddr,sizeof(servaddr))==-1){
printf("bindsocketerror:%s(errno:%d)
",strerror(errno),errno);
exit(0);
}

if(listen(listenfd,10)==-1){//开始监听，最大请求数为10，可以自己设置
printf("listensocketerror:%s(errno:%d)
",strerror(errno),errno);
exit(0);
}

printf("======waitingforclient'srequest======
");
	
while(1){
	//建立通信，等待客户端connect()函数的连接
if((connfd=accept(listenfd,(structsockaddr*)NULL,NULL))==-1)
	{
printf("acceptsocketerror:%s(errno:%d)",strerror(errno),errno);
continue;
}
n=recv(connfd,buff,MAXLINE,0);//n可以判断错误，此处可直接用recv()函数
	//接收到的信息存放在buff中
buff[n]='';//添加结束符
printf("recvmsgfromclient:%s
",buff);
close(connfd);
}

close(listenfd);
}