1.linux下socket 网络编程(客户端向服务器端发送文件) 求源代码 大哥大姐帮帮忙 。发发包。包源谢谢
2.TCP网络通讯如何解决分包粘包问题
3.sniffer状态
4.底层原理一道高频腾讯面试题:tcp数据发送问题
5.linux下socket 网络编程(客户端向服务器端发送文件) 求源代码 大哥大姐帮帮忙 ,工具。。发发包谢谢
6.Netty源码-一分钟掌握4种tcp粘包解决方案
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
#define SERVPORT
#define BACKLOG
int SendFileToServ(const char *path,发发包 const char *FileName, const char *ip)
{
#define PORT
int sockfd;
int recvbytes;
char buf[MAXDATASIZE];
char send_str[MAXDATASIZE];
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[%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[] = { 0};
char FileName[] = { 0};
char path[] = { 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", );
else if(2 == nret)
write(client_fd, "reload nginx error", );
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
#define SERVPORT
#define BACKLOG
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);
}
}
以前写的：内容忘记了。不是包源很复杂你可以自己看！
TCP网络通讯如何解决分包粘包问题
TCP作为常见的工具网络传输协议，在数据流解析上始终是发发包网络应用开发者面临的挑战。TCP数据传输基于无边界的包源数据流，发送端发送的工具数据量在接收端接收时可能不等同于发送量，从而引发粘包问题。
粘包情况包括：1. 多次发送的数据在接收端一次性读取，造成多次发送一次读取。这通常是因为网络流量优化，将多个小数据段集合成较大的数据量以减少传输次数。2. 数据段大小超过缓存大小，导致分批发送。
为解决TCP粘包问题，一种方法是定义数据包结构：包括数据头（如数据包大小，固定长度）和数据内容（长度由数据头定义）。实现如下：发送端先发送数据包大小，再发送数据内容；接收端先解析数据包大小，再读取指定字节数，确保完整读取数据内容。
具体流程：发送端将数据包大小和内容发送至接收端，接收端解析大小后读取相应字节数，确保完整接收。
测试用例：客户端模拟发送数据，服务端处理粘包问题。测试包括模拟数据分批到达（情况1）和一次性到达（情况2）。服务端需要将数据集满才能处理或逐个处理，确保正确解析。
推荐资源：LinuxC++音视频开发视频及学习资源，包括FFmpeg/WebRTC/RTMP/NDK/Android音视频流媒体高级开发等。
源码实现包括：server.cpp、client.cpp及Makefile。
测试结果：通过编译与运行，客户端模拟发送数据，服务端成功接收并处理数据，验证了解决粘包问题的方案。
sniffer状态
sniffer是窃听的意思
应该就是窃听状态
sniffers(嗅探器)几乎和internet有一样久的历史了.Sniffer是一种常用的收集有用数据方法，这些数据可以是用户的帐号和密码，可以是一些商用机密数据等等。随着Internet及电子商务的日益普及,Internet的安全也越来越受到重视。在Internet安全隐患中扮演重要角色之一的Sniffer以受到越来越大的关注，所以今天我要向大家介绍一下介绍Sniffer以及如何阻止sniffer。php合买源码
大多数的黑客仅仅为了探测内部网上的主机并取得控制权，只有那些"雄心勃勃"的黑客，为了控制整个网络才会安装特洛伊木马和后门程序，并清除记录。他们经常使用的手法是安装sniffer。
在内部网上，黑客要想迅速获得大量的账号（包括用户名和密码），最为有效的手段是使用 "sniffer" 程序。这种方法要求运行Sniffer 程序的主机和被监听的主机必须在同一个以太网段上，故而在外部主机上运行sniffer是没有效果的。再者，必须以root的身份使用sniffer 程序，才能够监听到以太网段上的数据流。谈到以太网sniffer，就必须谈到以太网sniffing。
那么什么是以太网sniffer呢?
以太网sniffing是指对以太网设备上传送的数据包进行侦听，发现感兴趣的包。如果发现符合条件的包，就把它存到一个log文件中
去。通常设置的这些条件是包含字"username"或"password"的包。它的目的是将网络层放到promiscuous模式，从而能干些事情。
Promiscuous模式是指网络上的所有设备都对总线上传送的数据进行侦听，并不仅仅是它们自己的数据。根据第二章中有关对以太网的工作原理的基本介绍，可以知道：一个设备要向某一目标发送数据时,它是对以太网进行广播的。一个连到以太网总线上的设备在任何时间里都在接受数据。不过只是将属于自己的数据传给该计算机上的应用程序。
利用这一点，可以将一台计算机的网络连接设置为接受所有以太
网总线上的数据，从而实现sniffer。
sniffer通常运行在路由器，或有路由器功能的主机上。这样就能对大量的数据进行监控。sniffer属第二层次的攻击。通常是攻击者已经进入了目标系统，然后使用sniffer这种攻击手段，以便得到更多的信息。
sniffer除了能得到口令或用户名外，还能得到更多的其他信息，比如一个其他重要的信息，在网上传送的金融信息等等。sniffer几乎能得到任何以太网上的传送的数据包。黑客会使用各种方法，获得系统的控制权并留下再次侵入的后门，以保证sniffer能够执行。在Solaris 2.x平台上，sniffer 程序通常被安装在/usr/bin 或/dev目录下。黑客还会巧妙的修改时间，使得sniffer程序看上去是ant design源码阅读和其它系统程序同时安装的。
大多数以太网sniffer程序在后台运行，将结果输出到某个记录文件中。黑客常常会修改ps程序，使得系统管理员很难发现运行的sniffer程序。
以太网sniffer程序将系统的网络接口设定为混合模式。这样，它就可以监听到所有流经同一以太网网段的数据包，不管它的接受者或发送者是不是运行sniffer的主机。 程序将用户名、密码和其它黑客感兴趣的数据存入log文件。黑客会等待一段时间 ----- 比如一周后，再回到这里下载记录文件。
讲了这么多，那么到底我们可以用什么通俗的话来介绍sniffer呢？
计算机网络与电话电路不同，计算机网络是共享通讯通道的。共享意味着计算机能够接收到发送给其它计算机的信息。捕获在网络中传输的数据信息就称为sniffing（窃听）。
以太网是现在应用最广泛的计算机连网方式。以太网协议是在同一回路向所有主机发送数据包信息。数据包头包含有目标主机的正确地址。一般情况下只有具有该地址的主机会接受这个数据包。如果一台主机能够接收所有数据包，而不理会数据包头内容，这种方式通常称为"混杂" 模式。
由于在一个普通的网络环境中，帐号和口令信息以明文方式在以太网中传输， 一旦入侵者获得其中一台主机的root权限，并将其置于混杂模式以窃听网络数据，从而有可能入侵网络中的所有计算机。
一句话，sniffer就是一个用来窃听的黑客手段和工具。
二、sniffer的工作原理
通常在同一个网段的所有网络接口都有访问在物理媒体上传输的所有数据的能力，而每个网络接口都还应该有一个硬件地址，该硬件地址不同于网络中存在的其他网络接口的硬件地址，同时，每个网络至少还要一个广播地址。（代表所有的接口地址），在正常情况下，一个合法的网络接口应该只响应这样的两种数据帧：
1、帧的目标区域具有和本地网络接口相匹配的硬件地址。
2、帧的目标区域具有"广播地址"。
在接受到上面两种情况的数据包时，nc通过cpu产生一个硬件中断，该中断能引起操作系统注意，然后将帧中所包含的数据传送给系统进一步处理。
而sniffer就是一种能将本地nc状态设成（promiscuous）状态的软件，当nc处于这种"混杂"方式时，该nc具备"广播地址"，vue 组件源码分析它对所有遭遇到的每一个帧都产生一个硬件中断以便提醒操作系统处理流经该物理媒体上的每一个报文包。（绝大多数的nc具备置成 promiscuous方式的能力）
可见，sniffer工作在网络环境中的底层，它会拦截所有的正在网络上传送的数据，并且通过相应的软件处理，可以实时分析这些数据的内容，进而分析所处的网络状态和整体布局。值得注意的是：sniffer是极其安静的，它是一种消极的安全攻击。
通常sniffer所要关心的内容可以分成这样几类：
1、口令
我想这是绝大多数非法使用sniffer的理由，sniffer可以记录到明文传送的userid和passwd.就算你在网络传送过程中使用了加密的数据，sniffer记录的数据一样有可能使入侵者在家里边吃肉串边想办法算出你的算法。
2、金融帐号
许多用户很放心在网上使用自己的信用卡或现金帐号，然而sniffer可以很轻松截获在网上传送的用户姓名、口令、信用卡号码、截止日期、帐号和pin.
3、偷窥机密或敏感的信息数据
通过拦截数据包，入侵者可以很方便记录别人之间敏感的信息传送，或者干脆拦截整个的email会话过程。
4、窥探低级的协议信息。
这是很可怕的事，我认为，通过对底层的信息协议记录，比如记录两台主机之间的网络接口地址、远程网络接口ip地址、ip路由信息和tcp连接的字节顺序号码等。这些信息由非法入侵的人掌握后将对网络安全构成极大的危害，通常有人用sniffer收集这些信息只有一个原因：他正在进行一次欺诈，（通常的ip地址欺诈就要求你准确插入tcp连接的字节顺序号,这将在以后整理的文章中指出）如果某人很关心这个问题，那么sniffer对他来说只是前奏，今后的问题要大得多。（对于高级的hacker而言，我想这是使用sniffer的唯一理由吧）
二.sniffer的工作环境
snifffer就是能够捕获网络报文的设备。嗅探器的正当用处在于分析网络的流量,以便找出所关心的网络中潜在的问题。例如,假设网络的某一段运行得不是很好,报文的发送比较慢,而我们又不知道问题出在什么地方,此时就可以用嗅探器来作出精确的问题判断。
嗅探器在功能和设计方面有很多不同。有些只能分析一种协议，而另一些可能能够分析几百种协议。一般情况下，大多数的嗅探器至少能够分析下面的协议：
1.标准以太网
2.TCP/IP
3.IPX
4.DECNet
嗅探器通常是软硬件的结合。专用的嗅探器价格非常昂贵。另一方面，免费的嗅探器虽然不需要花什么钱，但得不到什么支持。
嗅探器与一般的斗地主源码 cocos键盘捕获程序不同。键盘捕获程序捕获在终端上输入的键值，而嗅探器则捕获真实的网络报文。嗅探器通过将其置身于网络接口来达到这个目的——例如将以太网卡设置成杂收模式。（为了理解杂收模式是怎么回事，先解释局域网是怎么工作的）。
数据在网络上是以很小的称为帧(Ftame)的单位传输的帧由好几部分组成，不同的部分执行不同的功能。（例如，以太网的前个字节存放的是源和目的的地址，这些位告诉网络：数据的来源和去处。以太网帧的其他部分存放实际的用户数据、TCP/IP的报文头或IPX报文头等等）。
帧通过特定的称为网络驱动程序的软件进行成型，然后通过网卡发送到网线上。通过网线到达它们的目的机器，在目的机器的一端执行相反的过程。接收端机器的以太网卡捕获到这些帧，并告诉操作系统帧的到达，然后对其进行存储。就是在这个传输和接收的过程中，嗅探器会造成安全方面的问题。
每一个在LAN上的工作站都有其硬件地址。这些地址唯一地表示着网络上的机器（这一点于Internet地址系统比较相似）。当用户发送一个报文时，这些报文就会发送到LAN上所有可用的机器。
在一般情况下，网络上所有的机器都可以“听”到通过的流量，但对不属于自己的报文则不予响应（换句话说，工作站A不会捕获属于工作站B的数据，而是简单的忽略这些数据）。
如果某在工作站的网络接口处于杂收模式，那么它就可以捕获网络上所有的报文和帧，如果一个工作站被配置成这样的方式，它（包括其软件）就是一个嗅探器。
嗅探器可能造成的危害：
1.嗅探器能够捕获口令
2.能够捕获专用的或者机密的信息
3.可以用来危害网络邻居的安全，或者用来获取更高级别的访问权限
事实上，如果你在网络上存在非授权的嗅探器就以为着你的系统已经暴露在别人面前了。（大家可以试试天行2的嗅探功能）
一般我们只嗅探每个报文的前到个字节。用户名和口令都包含在这一部分中，这是我们关心的真正部分。工人，也可以嗅探给定接口上的所有报文，如果有足够的空间进行存储，有足够的那里进行处理的话，将会发现另一些非常有趣的东西……
简单的放置一个嗅探器宾将其放到随便什么地方将不会起到什么作用。将嗅探器放置于被攻击机器或网络附近，这样将捕获到很多口令，还有一个比较好的方法就是放在网关上。如果这样的话就能捕获网络和其他网络进行身份鉴别的过程。这样的方式将成倍地增加我们能够攻击的范围。
三.谁会使用sniffers
可能谁都回知道谁会使用sniffer，但是并不是每个使用它的人都是网络高手，因为现在有很多的sniffer都成了傻瓜似的了，前段时间用的最多的不外乎oicq sniffer。我想那些喜欢查好友ip的朋友都应该记得它吧。呵呵，我都使用过它，现在当然不用了啊！
当然系统管理员使用sniffer来分析网络信息交通并且找出网络上何处发生问题。一个安全管理员可以同时用多种sniffer, 将它们放置在网络的各处,形成一个入侵警报系统。对于系统管理员来说sniffer是一个非常好的工具,但是它同样是一个经常被黑客使用的工具.骇客安装sniffer以获得用户名和账号,信用卡号码,个人信息,和其他的信息可以导致对你或是你的公司的极大危害如果向坏的方面发展。当它们得到这些信息后,骇客将使用密码来进攻其他的internet 站点甚至倒卖信用卡号码。
三.sniffer是如何在网络上实施的
谈这个问题之前还应该先说一下Ethernet的通讯。通常在同一个网段的所有网络接口都有访问在媒体上传输的所有数据的能力，而每个网络接口都还应该有一个硬件地址，该硬件地址不同于网络中存在的其它网络接口的硬件地址，同时，每个网络至少还要一个广播地址。在正常情况下，一个合法的网络接口应该只响应这样的两种数据帧：
1�帧的目标区域具有和本地网络接口相匹配的硬件地址。
2�帧的目标区域具有“广播地址”。
在接受到上面两种情况的数据包时，网卡通过cpu产生一个硬件中断。该中断能引起操作系统注意，然后将帧中所包含的数据传送给系统进一步处理。而sniffer就是一种能将本地网卡状态设成杂乱模式（promiscuous Mode）的软件。当网卡处于杂乱模式时，该网卡具备“广播地址”，它对所有遇到的每一个帧都产生一个硬件中断以提醒操作系统处理每一个报文包。（绝大多数的网卡具备设置成杂乱模式的能力。
可见，sniffer工作在网络环境中的底层，它会拦截所有的正在网络上传送的数据。通过相应的软件处理，可以实时分析这些数据的内容，进而分析所处的网络状态和整体布局。值得注意的是：sniffer是极其安静的，它是一种消极的安全攻击。
四.哪里可以得到sniffer
我们讲的sniffer，主要是在unix系统下运用的，至于那些oicq sniffer就不在我们讨论的范围。
Sniffer是黑客们最常用的入侵手段之一。你可以在经过允许的网络中运行sniffer，了解它是如何有效地危及本地机器安全。
Sniffer可以是硬件，也可以是软件。现在品种最多,应用最广的是软件Sniffer,绝大多数黑客们用的也是软件Sniffer。
以下是一些也被广泛用于调试网络故障的sniffer工具：
（一）.商用sniffer：
1. Network General.
Network General开发了多种产品。最重要的是Expert Sniffer，它不仅仅可以sniff，还能够通过高性能的专门系统发送/接收数据包，帮助诊断故障。还有一个增强产品"Distrbuted Sniffer System"可以将UNIX工作站作为sniffer控制台，而将sniffer agents（代理）分布到远程主机上。
2. Microsoft's Net Monitor
对于某些商业站点，可能同时需要运行多种协议--NetBEUI、IPX/SPX、TCP/IP、.3和SNA等。这时很难找到一种sniffer帮助解决网络问题，因为许多sniffer往往将某些正确的协议数据包当成了错误数据包。Microsoft的Net Monitor（以前叫Bloodhound）可以解决这个难题。它能够正确区分诸如Netware控制数据包、NT NetBios名字服务广播等独特的数据包。（etherfind只会将这些数据包标识为类型的广播数据包。）这个工具运行在MS Windows 平台上。它甚至能够按MAC地址（或主机名）进行网络统计和会话信息监视。只需简单地单击某个会话即可获得tcpdump标准的输出。过滤器设置也是最为简单的，只要在一个对话框中单击需要监视的主机即可。
（二）.免费软件sniffer
1. Sniffit由Lawrence Berkeley 实验室开发，运行于Solaris、SGI和Linux等平台。可以选择源、目标地址或地址集合，还可以选择监听的端口、协议和网络接口等。这个SNIFFER默认状态下只接受最先的个字节的信息包，这对于一次登陆会话进程刚刚好。
2. SNORT：这个SNIFFER有很多选项供你使用并可移植性强，可以记录一些连接信息，用来跟踪一些网络活动。
3. TCPDUMP：这个SNIFFER很有名，linux,FREEBSD还搭带在系统上，是一个被很多UNIX高手认为是一个专业的网络管理工具，记得以前TsutomuShimomura（应该叫下村侵吧）就是使用他自己修改过的TCPDUMP版本来记录了KEVINMITNICK攻击他系统的记录，后来就配合FBI抓住了KEVINMITNICK，后来他写了一文：使用这些LOG记录描述了那次的攻击，HowMitnickhackedTsutomuShimomurawithanIPsequenceattack
( /~lspitz/snoop.html
（四）.Linux下的sniffer工具
Linux下的sniffer工具，我推荐Tcpdump。
[1].tcpdump的安装
在linux下tcpdump的安装十分简单，一般由两种安装方式。一种是以rpm包的形式来进行安装。另外一种是以源程序的形式安装。
1． rpm包的形式安装
这种形式的安装是最简单的安装方法，rpm包是将软件编译后打包成二进制的格式，通过rpm命令可以直接安装，不需要修改任何东西。以超级用户登录，使用命令如下：
#rpm -ivh tcpdump-3_4a5.rpm
这样tcpdump就顺利地安装到你的linux系统中。怎么样，很简单吧。
2． 源程序的安装
既然rpm包的安装很简单,为什么还要采用比较复杂的源程序安装呢?其实，linux一个最大的诱人之处就是在她上面有很多软件是提供源程序的，人们可以修改源程序来满足自己的特殊的需要。所以我特别建议朋友们都采取这种源程序的安装方法。
· 第一步 取得源程序 在源程序的安装方式中，我们首先要取得tcpdump的源程序分发包，这种分发包有两种 形式，一种是tar压缩包(tcpdump-3_4a5.tar.Z),另一种是rpm的分发包(tcpdump-3_4a5.src.rpm)。这两种 形式的内容都是一样的，不同的仅仅是压缩的方式.tar的压缩包可以使用如下命令解开：
#tar xvfz tcpdump-3_4a5.tar.Z
rpm的包可以使用如下命令安装:
#rpm -ivh tcpdump-3_4a5.src.rpm
这样就把tcpdump的源代码解压到/usr/src/redhat/SOURCES目录下.
· 第二步 做好编译源程序前的准备活动
在编译源程序之前，最好已经确定库文件libpcap已经安装完毕，这个库文件是tcpdump软件所需的库文件。同样，你同时还要有一个标准的c语言编译器。在linux下标准的c 语言编译器一般是gcc。 在tcpdump的源程序目录中。有一个文件是Makefile.in，configure命令就是从Makefile.in文件中自动产生Makefile文件。在Makefile.in文件中，可以根据系统的配置来修改BINDEST 和 MANDEST 这两个宏定义，缺省值是
BINDEST = @sbindir @
MANDEST = @mandir @
第一个宏值表明安装tcpdump的二进制文件的路径名，第二个表明tcpdump的man 帮助页的路径名,你可以修改它们来满足系统的需求。
· 第三步 编译源程序
使用源程序目录中的configure脚本，它从系统中读出各种所需的属性。并且根据Makefile.in文件自动生成Makefile文件，以便编译使用.make 命令则根据Makefile文件中的规则编译tcpdump的源程序。使用make install命令安装编译好的tcpdump的二进制文件。
总结一下就是:
# tar xvfz tcpdump-3_4a5.tar.Z
# vi Makefile.in
# . /configure
# make
# make install
[2].Tcpdump的使用
tcpdump采用命令行方式，它的命令格式为：
tcpdump [ -adeflnNOpqStvx ] [ -c 数量 ] [ -F 文件名 ]
[ -i 网络接口 ] [ -r 文件名] [ -s snaplen ]
[ -T 类型 ] [ -w 文件名 ] [表达式 ]
1. tcpdump的选项介绍
-a 将网络地址和广播地址转变成名字；
-d 将匹配信息包的代码以人们能够理解的汇编格式给出；
-dd 将匹配信息包的代码以c语言程序段的格式给出；
-ddd 将匹配信息包的代码以十进制的形式给出；
-e 在输出行打印出数据链路层的头部信息；
-f 将外部的Internet地址以数字的形式打印出来；
-l 使标准输出变为缓冲行形式；
-n 不把网络地址转换成名字；
-t 在输出的每一行不打印时间戳；
-v 输出一个稍微详细的信息，例如在ip包中可以包括ttl和服务类型的信息；
-vv 输出详细的报文信息；
-c 在收到指定的包的数目后，tcpdump就会停止；
-F 从指定的文件中读取表达式,忽略其它的表达式；
-i 指定监听的网络接口；
-r 从指定的文件中读取包(这些包一般通过-w选项产生)；
-w 直接将包写入文件中，并不分析和打印出来；
-T 将监听到的包直接解释为指定的类型的报文，常见的类型有rpc （远程过程 调用）和snmp（简单网络管理协议；）
2. tcpdump的表达式介绍
表达式是一个正则表达式，tcpdump利用它作为过滤报文的条件，如果一个报文满足表达式的条件，则这个报文将会被捕获。如果没有给出任何条件，则网络上所有的信息包将会被截获。
在表达式中一般如下几种类型的关键字，一种是关于类型的关键字，主要包括host，net，port, 例如 host ...2，指明 ...2是一台主机，net .0.0.0 指明 .0.0.0是一个网络地址，port 指明端口号是。如果没有指定类型，缺省的类型是host.
第二种是确定传输方向的关键字，主要包括src , dst ,dst or src, dst and src ,这些关键字指明了传输的方向。举例说明，src ...2 ,指明ip包中源地址是...2 , dst net .0.0.0 指明目的网络地址是.0.0.0 。如果没有指明方向关键字，则缺省是src or dst关键字。
第三种是协议的关键字，主要包括fddi,ip ,arp,rarp,tcp,udp等类型。Fddi指明是在FDDI(分布式光纤数据接口网络)上的特定的网络协议，实际上它是"ether"的别名，fddi和ether具有类似的源地址和目的地址，所以可以将fddi协议包当作ether的包进行处理和分析。其他的几个关键字就是指明了监听的包的协议内容。如果没有指定任何协议，则tcpdump将会监听所有协议的信息包。
除了这三种类型的关键字之外，其他重要的关键字如下：gateway, broadcast,less,greater,还有三种逻辑运算，取非运算是 'not ' '! ', 与运算是'and','&&';或运算 是'or' ,''；
这些关键字可以组合起来构成强大的组合条件来满足人们的需要，下面举几个例子来说明。
(1)想要截获所有...1 的主机收到的和发出的所有的数据包：
#tcpdump host ...1
(2) 想要截获主机...1 和主机...2 或...3的通信，使用命令：（在命令行中适用括号时，一定要
#tcpdump host ...1 and \ (...2 or ...3 \)
(3) 如果想要获取主机...1除了和主机...2之外所有主机通信的ip包，使用命令：
#tcpdump ip host ...1 and ! ...2
(4)如果想要获取主机...1接收或发出的telnet包，使用如下命令：
#tcpdump tcp port host ...1
3. tcpdump 的输出结果介绍
下面我们介绍几种典型的tcpdump命令的输出信息
(1) 数据链路层头信息
使用命令#tcpdump --e host ice
ice 是一台装有linux的主机，她的MAC地址是0：：：：AF：1A
H是一台装有SOLARIC的SUN工作站，它的MAC地址是8：0：：：5B：；上一条命令的输出结果如下所示：
::. eth0 < 8:0:::5b: 0::::af:1a ip : h. > ice.telne
t 0:0(0) ack win (DF)
分析：：：是显示的时间， 是ID号，eth0 <表示从网络接口eth0 接受该数据包，eth0 >表示从网络接口设备发送数据包, 8:0:::5b:是主机H的MAC地址,它表明是从源地址H发来的数据包. 0::::af:1a是主机ICE的MAC地址,表示该数据包的目的地址是ICE . ip 是表明该数据包是IP数据包, 是数据包的长度, h. > ice.telnet 表明该数据包是从主机H的端口发往主机ICE的TELNET()端口. ack 表明对序列号是的包进行响应. win 表明发送窗口的大小是.
(2) ARP包的TCPDUMP输出信息
使用命令#tcpdump arp
得到的输出结果是：
::. eth0 > arp who-has route tell ice (0::::af:1a)
::. eth0 < arp reply route is-at 0::::: (0::::af:1a)
分析: ::是时间戳, 是ID号, eth0 >表明从主机发出该数据包, arp表明是ARP请求包, who-has route tell ice表明是主机ICE请求主机ROUTE的MAC地址。 0::::af:1a是主机ICE的MAC地址。
(3) TCP包的输出信息
用TCPDUMP捕获的TCP包的一般输出信息是：
src > dst: flags data-seqno ack window urgent options
src > dst:表明从源地址到目的地址, flags是TCP包中的标志信息,S 是SYN标志, F (FIN), P (PUSH) , R (RST) "." (没有标记); data-seqno是数据包中的数据的顺序号, ack是下次期望的顺序号, window是接收缓存的窗口大小, urgent表明数据包中是否有紧急指针. Options是选项.
(4) UDP包的输出信息
用TCPDUMP捕获的UDP包的一般输出信息是：
route.port1 > ice.port2: udp lenth
UDP十分简单，上面的输出行表明从主机ROUTE的port1端口发出的一个UDP数据包到主机ICE的port2端口，类型是UDP， 包的长度是lenth上面，我就详细介绍了TCPDUMP的安装和使用，希望会对大家有所帮助。如果想要熟练运用TCPDUMP这个LINUX环境下的SNIFFER利器，还需要大家在实践中总结经验，充分发挥它的威力。
（五）.windows平台上的sniffer
我推荐netxray和sniffer pro软件，想必大家都用过他们，不过我在这儿还要再简单介绍一下他们。
netxray的使用说明
1.1.1.1----2.2.2.2----3.3.3.3----4.4.4.4 这是一个ShareHub连接下的局域网
5.5.5.5 这是一个端口上的/qinlizhong1/...
测试环境：MacOS .1, gcclinux下socket 网络编程(客户端向服务器端发送文件) 求源代码 大哥大姐帮帮忙 ,。。谢谢
源代码奉上，流程图。。。这个太简单了，你自己看看。。。。。。。
//TCP
//服务器端程序
#include< stdio.h >
#include< stdlib.h >
#include< windows.h >
#include< winsock.h >
#include< string.h >
#pragma comment( lib, "ws2_.lib" )
#define PORT
#define BACKLOG
#define TRUE 1
void main( void )
{
int iServerSock;
int iClientSock;
char *buf = "hello, world!\n";
struct sockaddr_in ServerAddr;
struct sockaddr_in ClientAddr;
int sin_size;
WSADATA WSAData;
if( WSAStartup( MAKEWORD( 1, 1 ), &WSAData ) )//初始化
{
printf( "initializationing error!\n" );
WSACleanup( );
exit( 0 );
}
if( ( iServerSock = socket( AF_INET, SOCK_STREAM, 0 ) ) == INVALID_SOCKET )
{
printf( "创建套接字失败!\n" );
WSACleanup( );
exit( 0 );
}
ServerAddr.sin_family = AF_INET;
ServerAddr.sin_port = htons( PORT );//监视的端口号
ServerAddr.sin_addr.s_addr = INADDR_ANY;//本地IP
memset( & ( ServerAddr.sin_zero ), 0, sizeof( ServerAddr.sin_zero ) );
if( bind( iServerSock, ( struct sockaddr * )&ServerAddr, sizeof( struct sockaddr ) ) == -1 )
{
printf( "bind调用失败!\n" );
WSACleanup( );
exit( 0 );
}
if( listen( iServerSock, BACKLOG ) == -1 )
{
printf( "listen调用失败!\n" );
WSACleanup( );
exit( 0 );
}
while( TRUE )
{
sin_size = sizeof( struct sockaddr_in );
iClientSock = accept( iServerSock, ( struct sockaddr * )&ClientAddr, &sin_size );
if( iClientSock == -1 )
{
printf( "accept调用失败!\n" );
WSACleanup( );
exit( 0 );
}
printf( "服务器连接到%s\n", inet_ntoa( ClientAddr.sin_addr ) );
if( send( iClientSock, buf, strlen( buf ), 0 ) == -1 )
{
printf( "send调用失败!" );
closesocket( iClientSock );
WSACleanup( );
exit( 0 );
}
}
}
/////客户端程序
#include< stdio.h >
#include< stdlib.h >
#include< windows.h >
#include< winsock.h >
#include< string.h >
#pragma comment( lib, "ws2_.lib" )
#define PORT
#define BACKLOG
#define TRUE 1
#define MAXDATASIZE
void main( void )
{
int iClientSock;
char buf[ MAXDATASIZE ];
struct sockaddr_in ServerAddr;
int numbytes;
// struct hostent *he;
WSADATA WSAData;
// int sin_size;
/* if( ( he = gethostbyname( "liuys" ) ) == NULL )
{
printf( "gethostbyname调用失败!" );
WSACleanup( );
exit( 0 );
}
*/
if( WSAStartup( MAKEWORD( 1, 1 ), &WSAData ) )//初始化
{
printf( "initializationing error!\n" );
WSACleanup( );
exit( 0 );
}
if( ( iClientSock = socket( AF_INET, SOCK_STREAM, 0 ) ) == INVALID_SOCKET )
{
printf( "创建套接字失败!\n" );
WSACleanup( );
exit( 0 );
}
ServerAddr.sin_family = AF_INET;
ServerAddr.sin_port = htons( PORT );
// ServerAddr.sin_addr = *( ( struct in_addr * )he->h_addr );
ServerAddr.sin_addr.s_addr = inet_addr( "..2." );//记得换IP
memset( &( ServerAddr.sin_zero ), 0, sizeof( ServerAddr.sin_zero ) );
if( connect( iClientSock, ( struct sockaddr * ) & ServerAddr, sizeof( struct sockaddr ) ) == -1 )
{
printf( "connect失败!" );
WSACleanup( );
exit( 0 );
}
numbytes = recv( iClientSock, buf, MAXDATASIZE, 0 );
if( numbytes == -1 )
{
printf( "recv失败!" );
WSACleanup( );
exit( 0 );
}
buf[ numbytes ] = '\0';
printf( "Received: %s", buf );
closesocket( iClientSock );
WSACleanup( );
}
/////UDP
//服务器
#include< stdio.h >
#include< string.h >
#include< winsock.h >
#include< windows.h >
#pragma comment( lib, "ws2_.lib" )
#define PORT
#define BACKLOG
#define TRUE 1
#define MAXDATASIZE
void main( void )
{
int iServerSock;
// int iClientSock;
int addr_len;
int numbytes;
char buf[ MAXDATASIZE ];
struct sockaddr_in ServerAddr;
struct sockaddr_in ClientAddr;
WSADATA WSAData;
if( WSAStartup( MAKEWORD( 1, 1 ), &WSAData ) )
{
printf( "initializationing error!\n" );
WSACleanup( );
exit( 0 );
}
iServerSock = socket( AF_INET, SOCK_DGRAM, 0 );
if( iServerSock == INVALID_SOCKET )
{
printf( "创建套接字失败!\n" );
WSACleanup( );
exit( 0 );
}
ServerAddr.sin_family = AF_INET;
ServerAddr.sin_port = htons( PORT );//监视的端口号
ServerAddr.sin_addr.s_addr = INADDR_ANY;//本地IP
memset( & ( ServerAddr.sin_zero ), 0, sizeof( ServerAddr.sin_zero ) );
if( bind( iServerSock, ( struct sockaddr * )&ServerAddr, sizeof( struct sockaddr ) ) == -1 )
{
printf( "bind调用失败!\n" );
WSACleanup( );
exit( 0 );
}
addr_len = sizeof( struct sockaddr );
numbytes = recvfrom( iServerSock, buf, MAXDATASIZE, 0, ( struct sockaddr * ) & ClientAddr, &addr_len );
if( numbytes == -1 )
{
printf( "recvfrom调用失败!\n" );
WSACleanup( );
exit( 0 );
}
printf( "got packet from %s\n", inet_ntoa( ClientAddr.sin_addr ) );
printf( "packet is %d bytes long\n", numbytes );
buf[ numbytes ] = '\0';
printf( "packet contains \"%s\"\n", buf );
closesocket( iServerSock );
WSACleanup( );
}
//客户端
#include< stdio.h >
#include< stdlib.h >
#include< windows.h >
#include< winsock.h >
#include< string.h >
#pragma comment( lib, "ws2_.lib" )
#define PORT
#define MAXDATASIZE
void main( void )
{
int iClientSock;
struct sockaddr_in ServerAddr;
int numbytes;
char buf[ MAXDATASIZE ] = { 0 };
WSADATA WSAData;
if( WSAStartup( MAKEWORD( 1, 1 ), &WSAData ) )
{
printf( "initializationing error!\n" );
WSACleanup( );
exit( 0 );
}
if( ( iClientSock = socket( AF_INET, SOCK_DGRAM, 0 ) ) == -1 )
{
printf( "创建套接字失败!\n" );
WSACleanup( );
exit( 0 );
}
ServerAddr.sin_family = AF_INET;
ServerAddr.sin_port = htons( PORT );
ServerAddr.sin_addr.s_addr = inet_addr( "..2." );//记得换IP
memset( &( ServerAddr.sin_zero ), 0, sizeof( ServerAddr.sin_zero ) );
numbytes = sendto( iClientSock, buf, strlen( buf ), 0, ( struct sockaddr * ) & ServerAddr, sizeof( struct sockaddr ) );
if( numbytes == -1 )
{
printf( "sendto调用失败!\n" );
WSACleanup( );
exit( 0 );
}
printf( "sent %d bytes to %s\n", numbytes, inet_ntoa( ServerAddr.sin_addr ) );
closesocket( iClientSock );
WSACleanup( );
}
Netty源码-一分钟掌握4种tcp粘包解决方案
TCP报文的传输过程涉及内核中recv缓冲区和send缓冲区。发送端，数据先至send缓冲区，经Nagle算法判断是否立即发送。接收端，数据先入recv缓冲区，再由内核拷贝至用户空间。
粘包现象源于无明确边界。解决此问题的关键在于界定报文的分界。Netty提供了四种方案来应对TCP粘包问题。
Netty粘包解决方案基于容器存储报文，待所有报文收集后进行拆包处理。容器与拆包处理分别在ByteToMessageDecoder类的cumulation与decode抽象方法中实现。
FixedLengthFrameDecoder是通过设置固定长度参数来识别报文，非报文长度，避免误判。
LineBasedFrameDecoder以换行符作为分界符，确保准确分割报文，避免将多个报文合并。
LengthFieldPrepender通过设置长度字段长度，实现简单编码，为后续解码提供依据。
LengthFieldBasedFrameDecoder则是一种万能解码器，能够解密任意格式的编码，灵活性高。
实现过程中涉及的参数包括：长度字段的起始位置offset、长度字段占的字节数lengthFieldLength、长度的调整lengthAdjustment以及解码后需跳过的字节数initialBytesToStrip。
在实际应用中，为自定义协议，需在服务器与客户端分别实现编码与解码逻辑。服务器端负责发送经过编码的协议数据，客户端则接收并解码，以还原协议信息。
