linuxcsendto

㈠ linux C语言编程,socket实现的即使通讯系统

//服务端server.c
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/wait.h>
#define SERVPORT 6000 /*服务器监听端口号 */
#define BACKLOG 10 /* 最大同时连接请求数 */
#define MAXDATASIZE 100

main()
{
char buf[MAXDATASIZE];
int sockfd,client_fd; /*sock_fd：监听socket；client_fd：数据传输socket */
struct sockaddr_in my_addr; /* 本机地址信息 */
struct sockaddr_in remote_addr; /* 客户端地址信息 */

if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
perror("socket创建出错！");
exit(1);
}
my_addr.sin_family=AF_INET;
my_addr.sin_port=htons(SERVPORT);
my_addr.sin_addr.s_addr = INADDR_ANY;
bzero(&(my_addr.sin_zero),8);
if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1)
{
perror("bind出错！");
exit(1);
}
if (listen(sockfd, BACKLOG) == -1)
{
perror("listen出错！");
exit(1);
}
while(1)
{
sin_size = sizeof(struct sockaddr_in);
if ((client_fd = accept(sockfd, (struct sockaddr *)&remote_addr, &sin_size)) == -1)
{
perror("accept出错");
continue;
}
printf("received a connection from %s\n", inet_ntoa(remote_addr.sin_addr));
if (!fork())
{ /* 子进程代码段 */
if ((recvbytes=recv(client_fd, buf, MAXDATASIZE, 0)) ==-1)
{
perror("recv出错！");
close(client_fd);
exit(0);
}
buf[recvbytes] = '\0';
printf("from client Received: %s",buf);

if (send(client_fd, "thanks!\n", 8, 0) == -1)
perror("send出错！");
close(client_fd);
exit(0);
}
close(client_fd);
}
}

//客户端client.c
#include<stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#define SERVPORT 6000
#define MAXDATASIZE 100

main(int argc, char *argv[])
{
int sockfd, recvbytes;
char buf[MAXDATASIZE];
struct hostent *host;
struct sockaddr_in serv_addr;
if (argc < 2)
{
fprintf(stderr,"Please enter the server's hostname!\n");
exit(1);
}
if((host=gethostbyname(argv[1]))==NULL)
{
herror("gethostbyname出错！");
exit(1);
}
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
perror("socket创建出错！");
exit(1);
}
serv_addr.sin_family=AF_INET;
serv_addr.sin_port=htons(SERVPORT);
serv_addr.sin_addr = *((struct in_addr *)host->h_addr);
bzero(&(serv_addr.sin_zero),8);
if (connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(struct sockaddr)) == -1)
{
perror("connect出错！");
exit(1);
}

if (send(sockfd, "hello!\n", 7, 0) == -1)
{
perror("send出错！");
exit(1);
}

if ((recvbytes=recv(sockfd, buf, MAXDATASIZE, 0)) ==-1)
{
perror("recv出错！");
exit(1);
}
buf[recvbytes] = '\0';
printf("Received: %s",buf);
close(sockfd);
}

㈡ 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);
}

㈢ 我在linux环境下编写udp客户端程序。为什么使用sendto发送数据时，接收端接收不到数据。

1、检查客户端和服务端的端口号是否一致；
2、接收端的socket要采用block模式,数据收到后打印出来.

㈣ linux 下C语言的syn扫描代码

//---------------------------------------------------------------------------
//Filename:ss.c
//Author:yunshu
//Write:2004-04-02
//Thanks Wineggdrop
//Modify:2004-09-08
//---------------------------------------------------------------------------

#include <winsock2.h>
#include <ws2tcpip.h>
#include <mstcpip.h>
#include <stdio.h>

#pragma comment(lib,"ws2_32.lib")

////////////////////////////////////////////////////////////////
//全局变量
////////////////////////////////////////////////////////////////

#define srcPort 88

char srcIP[20] = ;//定义源地址
char tgtIP[20] = ;//定义目的地址
int portNow;//定义正在扫描的端口

//标准端口列表
int ports[20] = ;

typedef struct ip_hdr
{
unsigned char h_verlen; //4位首部长度,4位IP版本号
unsigned char tos; //8位服务类型TOS
unsigned short total_len; //16位总长度（字节）
unsigned short ident; //16位标识
unsigned short frag_and_flags; //3位标志位
unsigned char ttl; //8位生存时间 TTL
unsigned char proto; //8位协议 (TCP, UDP 或其他)
unsigned short checksum; //16位IP首部校验和
unsigned int sourceIP; //32位源IP地址
unsigned int destIP; //32位目的IP地址
}IP_HEADER;

typedef struct tcp_hdr //定义TCP首部
{
USHORT th_sport; //16位源端口
USHORT th_dport; //16位目的端口
unsigned int th_seq; //32位序列号
unsigned int th_ack; //32位确认号
unsigned char th_lenres; //4位首部长度/6位保留字
unsigned char th_flag; //6位标志位
USHORT th_win; //16位窗口大小
USHORT th_sum; //16位校验和
USHORT th_urp; //16位紧急数据偏移量
}TCP_HEADER;

typedef struct tsd_hdr //定义TCP伪首部
{
unsigned long saddr; //源地址
unsigned long daddr; //目的地址
char mbz;
char ptcl; //协议类型
unsigned short tcpl; //TCP长度
}PSD_HEADER;

////////////////////////////////////////////////////////////////
//函数原形
////////////////////////////////////////////////////////////////

int send_packet();//发送数据函数
int recv_packet();//监听数据函数
USHORT checksum( USHORT *, int );//计算检验和函数
void usage( char * );//显示帮助函数
void check_port( char * );//判断端口是否开放函数

////////////////////////////////////////////////////////////////
//main函数
////////////////////////////////////////////////////////////////

int main( int argc , char *argv[] )
{
WSADATA WSAData;
DWORD thread_ID = 1;
char FAR hostname[128] = ;
HANDLE ThreadHandle[20];
struct hostent *phe;

if( argc != 2 )//检查命令行参数是否正确
{
usage( argv[0] );
exit( 0 );
}

if ( WSAStartup(MAKEWORD(2,2) , &WSAData) )
{
printf("WSAStartup Error...\n");
exit(0);
}

strcpy(tgtIP,argv[1]);//得到目标主机的ip地址

gethostname(hostname,128);//获取本机主机名

phe = gethostbyname(hostname);//获取本机ip地址结构

if(phe == NULL)
{
printf("Get LocalIP Error...\n");
}

strcpy(srcIP, inet_ntoa(*((struct in_addr *)phe->h_addr_list[0])));//得到本机ip地址

//调试用，注释掉
//printf("test\t%s\n",tgtIP);
//printf("test\t%s\n",srcIP);

//开启新线程，接受数据包，分析返回的信息
HANDLE RecvHandle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)recv_packet,NULL,0,&thread_ID);

Sleep(500);//休息一下再启动发送数据包函数

for(int tmp = 0; tmp < 20; tmp++)
{
++thread_ID;

//要扫描的端口
portNow = ports[tmp];

//开启新线程，发送数据包
ThreadHandle[tmp] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)send_packet,NULL,0,&thread_ID);

//防止生成线程过快，休息
Sleep(100);
}

DWORD WaitThread = WaitForMultipleObjects( 20 , ThreadHandle , TRUE , INFINITE );
if( WaitThread != WAIT_FAILED)
{
for( int n = 0 ; n < 20 ; n++ )
{
CloseHandle( ThreadHandle[n] );
}
}
CloseHandle( RecvHandle );

WSACleanup();
return 0;
}

//计算检验和函数，完全抄别人的
USHORT checksum(USHORT *buffer, int size)
{
unsigned long cksum=0;

while(size >1)
{
cksum += *buffer++;
size -= sizeof(USHORT);
}
if(size)
{
cksum += *(UCHAR*)buffer;
}
cksum = (cksum >> 16) + (cksum & 0xffff);
cksum += (cksum >> 16);
return (USHORT)(~cksum);
}

void usage(char *prog)
{
printf("===========================================\n");
printf("Used To Scan Remote Host's Ports\n");
printf("Usage:%s TargetIP\n",prog);
printf("===========================================\n");
exit(0);
}

//发送数据包的函数
int send_packet()
{
SOCKET sendSocket;
BOOL flag;
int timeout;
SOCKADDR_IN sin;
IP_HEADER ipHeader;
TCP_HEADER tcpHeader;
PSD_HEADER psdHeader;
char szSendBuf[60] = ;
int ret;
unsigned long source_ip;
unsigned long target_ip;

//建立原生数据socket
if((sendSocket = WSASocket(AF_INET, SOCK_RAW, IPPROTO_RAW, NULL, 0, WSA_FLAG_OVERLAPPED)) == INVALID_SOCKET)
{
printf("Socket Setup Error...\n");
return 0;
}

//设置自己填充数据包
if(setsockopt(sendSocket, IPPROTO_IP, IP_HDRINCL, (char *)&flag, sizeof(flag)) == SOCKET_ERROR)
{
printf("Setsockopt IP_HDRINCL Error...\n");
return 0;
}

//设置超时时间
timeout = 1000;
if(setsockopt(sendSocket, SOL_SOCKET, SO_SNDTIMEO, (char *)&timeout, sizeof(timeout)) == SOCKET_ERROR)
{
printf("Setsockopt SO_SNDTIMEO Error...\n");
return 0;
}

target_ip = inet_addr(tgtIP);
source_ip = inet_addr(srcIP);

sin.sin_family = AF_INET;
sin.sin_port = htons(portNow);
sin.sin_addr.S_un.S_addr = target_ip;

//填充IP首部
ipHeader.h_verlen = (4<<4 | sizeof(ipHeader)/sizeof(unsigned long));
ipHeader.total_len = htons(sizeof(ipHeader)+sizeof(tcpHeader));
ipHeader.ident = 1;
ipHeader.frag_and_flags = 0x40;
ipHeader.ttl = 128;
ipHeader.proto = IPPROTO_TCP;
ipHeader.checksum = 0;
ipHeader.sourceIP = source_ip;//源IP
ipHeader.destIP = target_ip;//目的IP

//填充TCP首部
tcpHeader.th_dport = htons(portNow);//目的端口
tcpHeader.th_sport = htons(srcPort); //源端口
tcpHeader.th_seq = 0x12345678;
tcpHeader.th_ack = 0;
tcpHeader.th_lenres = (sizeof(tcpHeader)/4<<4|0);
tcpHeader.th_flag = 2;//syn标志位。0,2,4,8,16,32->FIN,SYN,RST,PSH,ACK,URG（推测,哈哈）
tcpHeader.th_win = htons(512);
tcpHeader.th_urp = 0;
tcpHeader.th_sum = 0;

//填充tcp伪首部
psdHeader.saddr = ipHeader.sourceIP;
psdHeader.daddr = ipHeader.destIP;
psdHeader.mbz = 0;
psdHeader.ptcl = IPPROTO_TCP;
psdHeader.tcpl = htons(sizeof(tcpHeader));

//计算TCP校验和
memcpy(szSendBuf, &psdHeader, sizeof(psdHeader));
memcpy(szSendBuf + sizeof(psdHeader), &tcpHeader, sizeof(tcpHeader));

tcpHeader.th_sum = checksum((USHORT *)szSendBuf, sizeof(psdHeader) + sizeof(tcpHeader));

//计算IP检验和
memcpy(szSendBuf, &ipHeader, sizeof(ipHeader));
memcpy(szSendBuf + sizeof(ipHeader), &tcpHeader, sizeof(tcpHeader));
memset(szSendBuf + sizeof(ipHeader) + sizeof(tcpHeader), 0, 4);
ipHeader.checksum = checksum((USHORT *)szSendBuf, sizeof(ipHeader) + sizeof(tcpHeader));

memcpy(szSendBuf, &ipHeader, sizeof(ipHeader));
memcpy(szSendBuf + sizeof(ipHeader), &tcpHeader, sizeof(tcpHeader));

//发送数据包
ret = sendto(sendSocket, szSendBuf, sizeof(ipHeader) + sizeof(tcpHeader), 0, (struct sockaddr*)&sin, sizeof(sin));

if(ret == SOCKET_ERROR)
{
printf("Send Packet Error...\n");
return 0;
}
else return 1;
}

int recv_packet()
{
SOCKADDR_IN sniff;
SOCKET sock;
char recvBuffer[65000] = ;//缓冲区存放捕获的数据

//建立socket监听数据包
sock = socket(AF_INET,SOCK_RAW,IPPROTO_IP);

sniff.sin_family = AF_INET;
sniff.sin_port = htons(0);
sniff.sin_addr.s_addr = inet_addr(srcIP);

//绑定到本地随机端口
bind(sock,(PSOCKADDR)&sniff,sizeof(sniff));

//设置SOCK_RAW为SIO_RCVALL，以便接收所有的IP包
//来的
DWORD dwBufferLen[10] ;
DWORD dwBufferInLen = 1 ;
DWORD dwBytesReturned = 0 ;
WSAIoctl(sock,SIO_RCVALL,&dwBufferInLen,sizeof(dwBufferInLen),&dwBufferLen,sizeof(dwBufferLen),&dwBytesReturned,NULL,NULL);

while(TRUE)
{
memset(recvBuffer , 0 , sizeof(recvBuffer) );

//开始捕获数据包
int bytesRecived = recv(sock,recvBuffer,sizeof(recvBuffer),0);
if(bytesRecived <= 0)
{
break;
}
check_port(recvBuffer);
}
return 1;
}

void check_port(char *buffer)
{
IP_HEADER *ipHeader;//IP_HEADER型指针
TCP_HEADER *tcpHeader;//TCP_HEADER型指针

ipHeader = (IP_HEADER *)buffer;
tcpHeader = (TCP_HEADER *) (buffer+sizeof(IP_HEADER));

if(ipHeader->sourceIP != inet_addr(tgtIP))
{
return;
}

for(int tmp=0;tmp<20;tmp++)
{
//SYN+ACK -> 2+16=18（也是推测，哈哈）
if(tcpHeader->th_flag == 18 && tcpHeader->th_sport == htons(ports[tmp]))
{
printf("[Found]\t%s\tport\t%d\tOpen\n",tgtIP,ports[tmp]);
}
}
}

㈤ 如何在linux下用c语言编写一个能够发送icmp报文的小程序

需要建立来socket，参数是AF_INET，SOCK_RAW，IPPROTO_ICMP

自己构自造ICMP数据包，sendto发送给某地址。

ICMP有多种，你可以发送type为13的时间戳请求。

然后调用recvfrom会收到type为14的timestampreply的IP包，

IP头一般是20Bytes，里面包含srcIP，desIP还有TTL等。

IP包的数据就是返回ICMPtimestampreply报文，里面有origTimestamp，recvTimestamp，transStamp，可以计算出时间。

可以参考网页链接网页链接

觉得有帮助可以注册帐号，给他点个“星”

㈥ linux c下面 select函数的问题

是不是select实参传错了，都传入的是读的集合了。

㈦ Linux C 网络编程....使用socket通讯...

你可能使用的是TCP连接，这是基于连接发送，是流式传输，没有边界。
不过一般都有一个缓冲回区，满答了后才发送出去，要想没满就发送的话，就得使用推。

一个很重要的原因可能是你send的时候传入的第3个实参有问题。

另外有一点可能是低潮限制造成的。
可以用SO_SNDLOWAT套接字选项设置一个大一点的低潮。

另外你这样发送，可能会有主机大小端影响。最好是作为文本串来传输。

㈧ 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用c语言写的socket传文件。服务器以二进制流打开文件并发送，客户端接收并写入文件。

传输的时候没问题，主要是写的时候，这有个文件编码的问题，编码统一就好了。

㈩ Linux下的c语言UDP编程

read是直接复读取文件，scanf系列函数本身也制得用read读取文件。

bind是把socket和地址关联，INADDR_ANY的意思是任何地址。比如你的设备有很多ip，客户端向其中任何一个发送数据你的socket都能接收到。相应地如果你bind一个确定的ip的话，向其他ip发送数据你的socket是接收不到的。