《TCP/IP网络编程》中多线程HTTP服务器实现代码，线程池改编

最新推荐文章于 2024-06-21 16:50:07 发布
最新推荐文章于 2024-06-21 16:50:07 发布
阅读量339 收藏 1
点赞数 3
文章标签： 网络 服务器 tcp/ip
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43774168/article/details/136616587
版权

文章目录

最初代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <pthread.h>

#define BUF_SIZE 1024
#define SMALL_BUF 100

void* request_handler(void* arg);
void send_data(FILE *fp, char *ct, char *file_name);
const char* content_type(char *file);
void send_error(FILE *fp);
void error_handling(const char* message);

int main(int argc, char *argv[])
{
	if(argc!=2){
		printf("Usage: %s <port>\n", argv[0]);
		exit(1);
	}

	int serv_sock = socket(PF_INET, SOCK_STREAM, 0);

	int option = 1;
	int optlen = sizeof(option);
	setsockopt(serv_sock, SOL_SOCKET, SO_REUSEADDR, (void*)&option, optlen );

	struct sockaddr_in serv_adr;
	memset(&serv_adr,0 ,sizeof(serv_adr));
	serv_adr.sin_family = AF_INET;
	serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);	//本机IP
	serv_adr.sin_port = htons(atoi(argv[1]));	//本机端口

	if(bind(serv_sock,(struct sockaddr*)&serv_adr, sizeof(serv_adr) )== -1 )
	{
		error_handling("bind() error");
	}

	if(listen(serv_sock, 20) == -1 )
	{
		error_handling("listen() error");
	}

	while(1)
	{
		struct sockaddr_in clnt_adr;
		socklen_t clnt_adr_size = sizeof(clnt_adr);

		int clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_adr, &clnt_adr_size );
		printf("Connected Request: %s:%d\n", inet_ntoa(clnt_adr.sin_addr), ntohs(clnt_adr.sin_port) );
		pthread_t t_id;
		pthread_create(&t_id, NULL, request_handler, &clnt_sock);	
		pthread_detach(t_id);
	}
	close(serv_sock);
	return 0;
}

void* request_handler(void *arg)
{
	int clnt_sock =  *((int*)arg);
	char req_line[SMALL_BUF];

	FILE *clnt_read, *clnt_write;
	
	clnt_read = fdopen(clnt_sock, "r");		//读缓存
	clnt_write = fdopen( dup(clnt_sock), "w");	//写缓存
	
	fgets(req_line, SMALL_BUF, clnt_read);	//读数据（浏览器发数据给客户端）
	printf("req_line:%s\n",req_line);
	if(strstr(req_line,"HTTP/")==NULL  )	//不是HTTP协议
	{
		send_error(clnt_write);
		fclose(clnt_read);
		fclose(clnt_write);
		return NULL;
	}

	char method[10],file_name[30],ct[15];
	strcpy( method, strtok(req_line, " /")  );
	strcpy( file_name, strtok(NULL, " /") );
	strcpy( ct, content_type(file_name));
	
	if(strcmp(method, "GET") !=0)	//不是GET方法
	{
		send_error(clnt_write);
		fclose(clnt_read);
		fclose(clnt_write);
		return NULL;
	}
	
	fclose(clnt_read);
	send_data(clnt_write, ct, file_name);

	return NULL;
}

void send_data(FILE *fp, char *ct, char *file_name)
{
	char protocol[] = "HTTP/1.0 200 OK\r\n";
	char server[] = "Server:Linux Web Server \r\n"; 
	char cnt_len[] = "Content-length:2048\r\n";

	char cnt_type[SMALL_BUF];
	char buf[BUF_SIZE];

	sprintf(cnt_type, "Content-type:%s\r\n\r\n",ct);
	FILE* send_file = fopen(file_name, "r");
	if(send_file == NULL)
	{
		send_error(fp);
		fclose(fp);
		return;
	}

	fputs(protocol, fp);
	fputs(server, fp);	
	fputs(cnt_len, fp);
	fputs(cnt_type, fp);

	while(fgets(buf,BUF_SIZE,send_file)!=NULL)
	{
		fputs(buf, fp);
		fflush(fp);
	}
	fflush(fp);
	fclose(fp);
}

const char* content_type(char *file)
{
	char extension[SMALL_BUF];
	char file_name[SMALL_BUF];
	strcpy(file_name, file);

	strtok(file_name,".");
	strcpy(extension, strtok(NULL,".") );

	if(!strcmp(extension, "html")||!strcmp(extension,"htm") )
	{
		return "text/html";
	}
	else
	{
		return "text/plain";
	}
}	

void send_error(FILE *fp)
{
	char protocol[] = "HTTP/1.0 400 Bad Request\r\n";	//状态行
	char server[] = "Server:Linux Web Server\r\n";		//消息头
	char cnt_len[] = "Content-length:2048\r\n";
	char cnt_type[] = "Content-type:text/html\r\n\r\n";	//空行

	char content[] = "<html><head><title>NETWORK </title> </head>"
			  "<body> <font size=+5> <br>404 Error!  </font>   </body>  </html>";
	
	fputs(protocol, fp);
	fputs(server, fp);
		
	fputs(cnt_len, fp);
	fputs(cnt_type, fp);
	fputs(content, fp);
	
	fflush(fp);

}

void error_handling(const char *message)
{
	fputs(message, stderr);
	fputc('\n',stderr);
	exit(1);
}

线程池代码

locker.h

#ifndef LOCKER_H
#define LOCKER_H

#include <exception>
#include <pthread.h>
#include <semaphore.h>

/*封装信号量的类*/
class Sem
{
public:
	/*创建并初始化信号量*/
	Sem()
	{
		if( sem_init( &m_sem, 0, 0 )!=0 )
		{
			/* 构造函数没有返回值，抛出异常来报告错误*/
			throw std::exception();
		}
	}
	/*销毁信号量*/
	~Sem()
	{
		sem_destroy(&m_sem);
	}
	/*等待信号量*/
	bool wait()
	{
		return sem_wait( &m_sem ) == 0;
	}
	/*增加信号量*/
	bool post()
	{
		return sem_post( &m_sem ) == 0;
	}
private:
	sem_t m_sem;
};

/*封装互斥锁*/
class Locker
{
public:
	/*创建并初始化互斥锁*/
	Locker()
	{
		if( pthread_mutex_init(&m_mutex, NULL) != 0 )
		{
			throw std::exception();
		}
	}
	/*销毁互斥锁*/
	~Locker()
	{
		pthread_mutex_destroy( &m_mutex );
	}
	/*获取互斥锁*/
	bool lock()
	{
		return pthread_mutex_lock(&m_mutex) == 0 ;
	}
	/*释放互斥锁*/
	bool unlock()
	{
		return pthread_mutex_unlock(&m_mutex) == 0 ;
	}
private:
	pthread_mutex_t m_mutex;
};

#endif

threadpool.h

#ifndef THREADPOOL_H
#define THREADPOOL_H

#include <list>
#include <cstdio>
#include <exception>
#include <pthread.h>
#include <semaphore.h>
#include "locker.h"

/*线程池类， 将它定义为模板类是为了代码复用。模板参数T是任务类*/
template< typename T >
class ThreadPool
{
public:
	ThreadPool(int thread_number = 8, int max_requests = 10000 );
	~ThreadPool();
	/*往请求队列中添加任务*/
	bool append(T* request);

private:
	/*工作线程运行的函数，它不断从工作队列中取出任务并执行之*/
	static void* worker(void* arg);
	void run();
private:
	int m_thread_number;	//线程池中的线程数
	int m_max_requests;	//请求队列中允许的最大请求数
	pthread_t *m_threads;	//线程描述符数组，大小为m_thread_number	
	std::list<T*> m_workqueue;	/*请求队列 T是任务类*/
	Locker m_queuelocker;	//保护请求队列的互斥锁
	Sem m_queuestat;	//是否有任务需要处理，唤醒
	bool m_stop;		//是否结束线程
};

template <typename T>
ThreadPool<T>::ThreadPool(int thread_number, int max_requests):m_thread_number(thread_number),m_max_requests(max_requests),m_stop(false),m_threads(NULL){
	if(thread_number<=0||max_requests<=0 ) 
	{
		throw std::exception();
	}
	
	m_threads = new pthread_t[m_thread_number];		//动态分配
	if(!m_threads)
	{
		throw std::exception();
	}
	
	/*创建thread_number个线程，并将它们设置为脱离线程*/
	for(int i=0;i<thread_number;i++)
	{
		printf("create the %dth thread\n", i);
		if(pthread_create(m_threads+i, NULL, worker, this ) != 0)	//线程执行worker函数（工作者），把线程池对象传入线程，执行线程的run()函数
		{
			delete[] m_threads;
			throw std::exception();
		}
		if( pthread_detach(m_threads[i]) )
		{
			delete[] m_threads;
			throw std::exception();
		}
	}
}

template< typename T>
ThreadPool<T>::~ThreadPool()
{
	delete[] m_threads;
	m_stop = true;
}

template< typename T>
bool ThreadPool<T>::append(T* request)
{
	/*操作工作队列时一定要加锁*/
	m_queuelocker.lock();
	if(m_workqueue.size() > m_max_requests )	
	{
		m_queuelocker.unlock();
		return false;
	}	
	m_workqueue.push_back(request);	//任务加入队列

	m_queuelocker.unlock();
	m_queuestat.post();		//wait() P, post() V	V操作唤醒run()
	return true;
}

template< typename T>
void* ThreadPool<T>::worker(void* arg)
{
	ThreadPool *pool = (ThreadPool*)arg;
	pool->run();
	return pool;
}

template< typename T>
void ThreadPool<T>::run()
{
	while(!m_stop)
	{
		m_queuestat.wait();	//P操作，有请求
		m_queuelocker.lock();
		if(m_workqueue.empty() )
		{
			m_queuelocker.unlock();
			continue;
		}

		T* request = m_workqueue.front();
		m_workqueue.pop_front();
		m_queuelocker.unlock();

		if(!request)
		{
			continue;
		}
		request->process();
		delete request;
	}
}

#endif

task.h

#ifndef TASK_H
#define TASK_H

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <pthread.h>

#define SMALL_BUF 100
#define BUF_SIZE 1024

class Task{
public:
	Task(int clnt_sock):m_clnt_sock(clnt_sock){
		
	}
	void process();
	void send_data(FILE *fp, char *ct, char *file_name);
	const char* content_type(char *file);
	void send_error(FILE *fp);
	void error_handling(const char *message);
private:
	int m_clnt_sock;
};

void Task::process()
{	
	int clnt_sock = m_clnt_sock;
	char req_line[SMALL_BUF];

	FILE *clnt_read, *clnt_write;
	
	clnt_read = fdopen(clnt_sock, "r");		//读缓存
	clnt_write = fdopen( dup(clnt_sock), "w");	//写缓存
	
	fgets(req_line, SMALL_BUF, clnt_read);	//读数据（浏览器发数据给客户端）
	printf("req_line:%s\n",req_line);
	if(strstr(req_line,"HTTP/")==NULL  )	//不是HTTP协议
	{
		send_error(clnt_write);
		fclose(clnt_read);
		fclose(clnt_write);
		return;
	}

	char method[10],file_name[30],ct[15];
	strcpy( method, strtok(req_line, " /")  );
	strcpy( file_name, strtok(NULL, " /") );
	strcpy( ct, content_type(file_name));
	
	if(strcmp(method, "GET") !=0)	//不是GET方法
	{
		send_error(clnt_write);
		fclose(clnt_read);
		fclose(clnt_write);
		return;
	}
	
	fclose(clnt_read);
	send_data(clnt_write, ct, file_name);
}


void Task::send_data(FILE *fp, char *ct, char *file_name)
{
	char protocol[] = "HTTP/1.0 200 OK\r\n";
	char server[] = "Server:Linux Web Server \r\n"; 
	char cnt_len[] = "Content-length:2048\r\n";

	char cnt_type[SMALL_BUF];
	char buf[BUF_SIZE];

	sprintf(cnt_type, "Content-type:%s\r\n\r\n",ct);
	FILE* send_file = fopen(file_name, "r");
	if(send_file == NULL)
	{
		send_error(fp);
		fclose(fp);
		return;
	}

	fputs(protocol, fp);
	fputs(server, fp);	
	fputs(cnt_len, fp);
	fputs(cnt_type, fp);

	while(fgets(buf,BUF_SIZE,send_file)!=NULL)
	{
		fputs(buf, fp);
		fflush(fp);
	}
	fflush(fp);
	fclose(fp);
}

const char* Task::content_type(char *file)
{
	char extension[SMALL_BUF];
	char file_name[SMALL_BUF];
	strcpy(file_name, file);

	strtok(file_name,".");
	strcpy(extension, strtok(NULL,".") );

	if(!strcmp(extension, "html")||!strcmp(extension,"htm") )
	{
		return "text/html";
	}
	else
	{
		return "text/plain";
	}
}


void Task::send_error(FILE *fp)
{
	char protocol[] = "HTTP/1.0 400 Bad Request\r\n";	//状态行
	char server[] = "Server:Linux Web Server\r\n";		//消息头
	char cnt_len[] = "Content-length:2048\r\n";
	char cnt_type[] = "Content-type:text/html\r\n\r\n";	//空行

	char content[] = "<html><head><title>NETWORK </title> </head>"
			  "<body> <font size=+5> <br>404 Error!  </font>   </body>  </html>";
	
	fputs(protocol, fp);
	fputs(server, fp);
		
	fputs(cnt_len, fp);
	fputs(cnt_type, fp);
	fputs(content, fp);
	
	fflush(fp);
}		

void Task::error_handling(const char *message)
{
	fputs(message, stderr);
	fputc('\n',stderr);
	exit(1);
}

#endif

main.cpp

#include "locker.h"
#include "threadpool.h"
#include "task.h"
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <pthread.h>

#define BUF_SIZE 1024
#define SMALL_BUF 100

void error_handling(const char* message)
{
	fputs(message, stderr);
	fputc('\n',stderr);
	exit(1);
}

int main(int argc, char *argv[] )
{
	/*ThreadPool<Task> *pool = NULL;
	try
	{
		pool = new ThreadPool<Task>;
	}
	catch(...)
	{
		return 1;
	}
	for(int i = 0; i<5; i++)
	{
		pool->append(new Task());
	}	
	sleep(20);*/
	if(argc!=2){
		printf("Usage: %s <port>\n", argv[0]);
		exit(1);
	}

	int serv_sock = socket(PF_INET, SOCK_STREAM, 0);

	int option = 1;
	int optlen = sizeof(option);
	setsockopt(serv_sock, SOL_SOCKET, SO_REUSEADDR, (void*)&option, optlen );

	struct sockaddr_in serv_adr;
	memset(&serv_adr,0 ,sizeof(serv_adr));
	serv_adr.sin_family = AF_INET;
	serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);	//本机IP
	serv_adr.sin_port = htons(atoi(argv[1]));	//本机端口

	if(bind(serv_sock,(struct sockaddr*)&serv_adr, sizeof(serv_adr) )== -1 )
	{
		error_handling("bind() error");
	}

	if(listen(serv_sock, 20) == -1 )
	{
		error_handling("listen() error");
	}

	ThreadPool<Task> *pool = NULL;
        try
        {
                pool = new ThreadPool<Task>;
        }
        catch(...)
        {
                return 1;
        }
	
	while(1)
	{
		struct sockaddr_in clnt_adr;
		socklen_t clnt_adr_size = sizeof(clnt_adr);

		int clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_adr, &clnt_adr_size );
		printf("Connected Request: %s:%d\n", inet_ntoa(clnt_adr.sin_addr), ntohs(clnt_adr.sin_port) );

		pool->append(new Task(clnt_sock));
		
		/*pthread_t t_id;
		pthread_create(&t_id, NULL, request_handler, &clnt_sock);	
		pthread_detach(t_id);*/
	}
		
	close(serv_sock);

	return 0;
}

index.html

<html>
<head><title>Network</title>  </head>

<body>
<font size= +5><br> net_program interesting! </font>
</body>

</html>

编译

g++ -g locker.h task.h threadpool.h main.cpp -o main -lpthread

执行结果

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

weixin_43774168
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
《TCP/IP网络编程》尹圣雨-各章节代码汇总
09-15
内容概要：主要收录了《TCP/IP网络编程》这本书每个章节内容所用到的代码，可以直接运行（是C语言文件，最好在Linux系统中运行使用） 适合人群：有一定编程语言基础，网络编程方面零基础也可学习 能学到什么：结合...
《TCP/IP网络编程》尹圣雨 例程源码
02-03
《TCP/IP网络编程》尹圣雨 例程源码
《Linux多线程服务端编程：使用muduoC++网络库》学习笔记
qq_40586164的博客
02-02 2381
boost库安装： apt-cache search boost 搜到所有的boost库 然后： sudo apt-get install libboost-all-dev 安装相应的库 第一章 线程安全的对象生命期管理 1.1 当析构函数遇到多线程 C++多线程对象的销毁可能会碰到竞态条件，解决办法是使用shared_ptr。 1.1.1 线程安全的定义 1.1.2 MutexLock与MutexLockGuard #include<bits/stdc++.h> #include<b
网络基础学习系列二(socket编程)
sakeww的博客
07-14 813
socket编程
第 7 章网络可扩展性
allway2的博客
08-28 3195
网络可伸缩性涉及以这样一种方式构建应用程序，即随着对应用程序的更多需求，它可以进行调整以处理压力。需求可能以更多用户、更多请求、更复杂的请求以及网络特性的变化的形式出现。 有几个值得关注的领域如下： 服务器容量 多线程 网络带宽和延迟 执行环境 可扩展性可以通过增加更多的服务器、使用适当数量的线程、提高执行环境的性能、增加网络带宽来消除瓶颈来实现。 添加更多服务器将有助于启用服务器之间的负载平衡。但是，如果网络带宽或延迟是问题，那么这将无济于事。只有这么多可以通过网络管道推送。 线程经常用..
从IO谈论编程的基础
lxlmycsdnfree的博客
10-27 473
当然我们使用的是高级开发语言，高级开发语言开发的程序有借助运行的虚拟机或者经过编译器编译之后都是本质调用系统的pthread. 这里举一个例子，对于java语言有中间运行的jvm,而且上面的资源全都是jdk封装的，如容器，内存的管理（堆栈），还有线程。要是网卡读取数据，网卡会告知系统最后的tcp/udp包结束。一个线程创建被执行之后，就会进入到内核态，内核就会给线程分配一个的空间，对于我们通常所说的内存管理是用户空间的内存管理，执行在内核中的线程会将操作的寄存器数据值写回到用户空间中对应的变量地址中。
C++ 如何进阶？
qq_40989769的博客
05-06 1087
按照上面推荐的内容来学习的话，要学习得深入一点的话1年的时间肯定需要的，甚至2年也不足为 其。当然对于非科班的学生来说，大部分都没有充足的时间的，这时候建议尽量把C++基础、计算 机网络、操作系统、 网络编程、数据结构与算法这五个部分的内容学得很扎实，大概6个月的时间。t=N7T8t=N7T8t=N7T8t=N7T8t=N7T8t=N7T84个小时搞懂tcp/ip协议栈，从tcp/ip协议栈原理到实现一个网络协议栈https://www.bilibili.com/video/BV1NA411y7Vc/
基于多层结构的网络游戏平台的研究与应用
11-01 1万+
基于多层结构的网络游戏平台的研究与应用 学科专业: 计算机软件与理论 研究方向: 计算机软件 导 师: 李 祥 教授 研 究 生: 匡 华 中国 · 贵州 · 贵阳 2007年 5 月 本文的主要工作在《天骄II》、《傲世online》、《凤舞天骄》中得到了实际运用 目 录 第一章 前言 8 1.1 网络游戏平台的发展背景 8 1.2 国内外现状 9 1.3 本文的研
【转载】基于多层结构的网络游戏平台的研究与应用
热门推荐
思月行云
07-21 3万+
本文纯粹收藏，如有再转，请按如下方式详细标明文章题目、作者及其导师信息，以示尊重。由此所引发的版权问题与本博无关！<br />来源：http://www.cnblogs.com/bluespot/archive/2008/07/13/1241950.html基于多层结构的网络游戏平台的研究与应用 基于多层结构的网络游戏平台的研究与应用 学科专业: 计算机软件与理论 研究方向: 计算机软件 导 师: 李 祥 教授 研 究 生: 匡 华 中国 · 贵州 · 贵阳 2007年 5 月
【八股】2024春招八股复习笔记3（测试、运维、安全、游戏、客户端）
小哈里的博客
03-27 2271
1、测试开发 2、运维开发 SRE 3、安全开发 4、运营开发/应用开发（全栈） 5、客户端：PC & 移动 & 游戏 我有一个问题，既然测试、运维、安全、运营、客户端都要会开发，同时还要会很多专业领域的知识，但是待遇和职业发展却都远远不如开发。那为什么不直接投业务开发呢（好吧可能是太卷了） 1、测试开发 1、网络 & 系统（含linux） 2、数据库，MySQL，JAVA 3、测试流程：单元测试、集成测试、系统测试 【八股】2024春招八股复习笔记3（测试、运维、安全、游戏、客户端）
1 项目总结（编程项目+ 实验室项目）
Austrialia的博客
07-22 2266
谷粒学院在线教育 简介 项目经历主要包括一个关于Java后端开发的在线教育项目。该项目主要分为前台系统和后台系统，前台系统实现了数据显示、课程列表显示、课程支付等功能，后台系统主要实现了课程管理、教师管理、权限管理、用户登录注册、短信模块、视频存储等模块。项目采用前后端分离开发，后端主要采用springboot+springcloud微服务架构，基于JWT+token+cookie实现单点登录，使用springsecurity进行权限管理，Spring Cloud实现请求转发、功能模块微服务化、服务调用、请
tcp/ip网络编程参考代码
12-04
基于linux平台的tcp/ip网络编程参考代码，包括server端和client端代码，支持linux pc、嵌入式linux以及android（底层），支持gcc和ndk编译，已经验证通过，欢迎下载
通信与网络中的基于TCP/IP协议的嵌入式网络打印服务器的实现
12-10
摘要：运用嵌入式Internet技术，设计了一个基于TCP/IP协议的嵌入式网络打印服务器，给出了系统中TCP/IP协议的剪裁方案，分析了系统软硬件的设计思路,最后通过测试程序验证了其可行性。 关键词：嵌入式 以太网 TCP/IP...
离线使用端口扫描工具Nmap和Netcat
最新发布
生活不只是眼前的苟且,还有诗和远方!
06-21 870
这个扫描是针对本地计算机的 localhost 地址进行的，即本机回环地址。localhost 是一个特殊的网络地址，指向本机的 IP 地址（通常是 127.0.0.1）。这个扫描是针对网络中的一台具体主机（IP地址为 10.16.36.204）进行的。Nmap（Network Mapper）是一个强大的网络扫描和安全审计工具，它支持多种扫描技术和方法。所以，这次扫描是在本机上执行的，它展示了本机上所有运行的服务和开放的端。# 扫描报告，显示扫描的目标是本地主机（127.0.0.1）
使用 Python 中的美丽汤进行网络数据解析的完整指南
SmartGarret的博客
06-20 980
如果你已经迷上了数据解析的概念，你可能会尝试打开 HTML 文档，阅读其中的信息，感觉就像在尝试破译古老的象形文字。你也可能把它看成是一碗汤–把各种配料放在一起，切片、煮沸、烹饪。它们一起构成了美味的一餐，但如果你试图挑出每一片胡萝卜（不管出于什么原因），你可能就会意识到这是一项多么复杂的工作。Beautiful Soup 来拯救你了，它能让你的汤更美。它是一个 Python 库，通常用于刮取和解析 HTML 和 XML 文档，并提供导航和搜索其中内容的工具。
不出网上线CS的各种姿势（内网横向）
qq_64395221的博客
06-21 949
在内网环境中可以使用ipc $生成的SMB Beacon上传到目标主机执行，但是目标主机并不会直接上线的，需要我们自己用链接命令(link <ip>)去连接它。经常是拿下一台边缘机器，其有多块网卡，用于连接内外网，内网机器都不出网。因为连接的Beacons使用Windows命名管道进行通信，此流量封装在SMB协议中，所以SMB Beacon相对隐蔽，绕防火墙时可能发挥奇效。一样，建立pystinger连接之后，直接生成payload在业务主机执行，业务内网主机192.168.111.236即可成功上线。
Java——包
Stewie Lee的博客
06-21 879
包是Java命名空间机制的一部分，用于将相关的类、接口和子包进行分组，以避免命名冲突和提高代码的可维护性，以及控制类、接口等的访问范围。在一个Java源文件的开头使用package关键字来声明它所属的包。
网络编程1
bonfirelit的博客
06-21 310
服务器接收到 FIN 包后，会向客户端发送一个 ACK（Acknowledgment）包，确认已经接收到 FIN。客户端接收到服务器的 FIN 包后，向服务器发送一个 ACK 包，确认已经接收到 FIN。网络编程中，客户端调用close或者shutdown后，操作系统会给服务器发送一个FIN。操作系统会发送一个 FIN 包给服务器，表示客户端不会再发送数据。服务器进入半关闭状态，可以继续向客户端发送数据，但不能再接收数据。当双方都发送并接收到 FIN 和 ACK 包后，连接才完全关闭。
tcp/ip网络编程pdf
10-13
《TCP/IP网络编程PDF》是一本关于TCP/IP网络编程的电子书。TCP/IP是一种网络协议，用于在互联网络中传输数据。这本电子书通过介绍TCP/IP协议族的各个方面，教授读者如何进行网络编程。 这本电子书首先介绍了TCP/IP...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值