http server样例

最新推荐文章于 2024-03-20 20:32:29 发布
最新推荐文章于 2024-03-20 20:32:29 发布
阅读量3.4k 收藏 2
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xbgprogrammer/article/details/16971453
版权 
// TopdeskSvr.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <http.h>
#include <Windows.h>
#include <assert.h>
#include <iostream>
#include <conio.h>
#include <process.h>
#include <atlbase.h>
#include <string>
#include <atlstr.h>
using namespace std;

#pragma comment(lib, "httpapi.lib")
#define CPK 1
#define CK_EXIT 0
#define TRDCOUNT 10
#define BUFFERLEN 16*1024
#define ITEM(x) {x, _T(#x)}
#define ADD_KNOWN_HEADER(Response, HeaderId, RawValue)               \
	do                                                               \
{                                                                \
	(Response).Headers.KnownHeaders[(HeaderId)].pRawValue =      \
	(RawValue);\
	(Response).Headers.KnownHeaders[(HeaderId)].RawValueLength = \
	(USHORT) strlen(RawValue);                               \
} while(FALSE)
#define CHECKRETUL(ul) if (ul!=NO_ERROR)\
{\
	cout<<"ur="<<ul<<endl;\
}

void _send_http_response(HTTP_REQUEST* HttpRequest,HANDLE ReqQueueHandle, BOOL bAnsyc=FALSE);

enum IO_OPERATION
{
	ClientIORead,
	ClientIOWrite
};

typedef struct _TRDCONTEXT
{
	HANDLE hCompletionPort;
	HANDLE ReqQueueHandle;
}TRDCONTEXT, *PTRDCONTEXT;

struct OVERLAPPEDEX : OVERLAPPED 
{
	CHAR   buffer[BUFFERLEN];
	HTTP_REQUEST_ID HttpRequestId;
	IO_OPERATION IOType;
	HANDLE hFile;
};

struct HTTP_HEADER_DESC 
{
	HTTP_HEADER_ID id;
	PCTSTR desc;
};

HTTP_HEADER_DESC gvRequestHeaderDesc[]={
	ITEM(HttpHeaderCacheControl),
	ITEM(HttpHeaderConnection),
	ITEM(HttpHeaderDate),
	ITEM(HttpHeaderKeepAlive),
	ITEM(HttpHeaderPragma),
	ITEM(HttpHeaderTrailer),
	ITEM(HttpHeaderTransferEncoding),
	ITEM(HttpHeaderUpgrade),
	ITEM(HttpHeaderVia),
	ITEM(HttpHeaderWarning),
	ITEM(HttpHeaderAllow),
	ITEM(HttpHeaderContentLength),
	ITEM(HttpHeaderContentType),
	ITEM(HttpHeaderContentEncoding),
	ITEM(HttpHeaderContentLanguage),
	ITEM(HttpHeaderContentLocation),
	ITEM(HttpHeaderContentMd5),
	ITEM(HttpHeaderContentRange),
	ITEM(HttpHeaderExpires),
	ITEM(HttpHeaderLastModified),
	ITEM(HttpHeaderAccept),
	ITEM(HttpHeaderAcceptCharset),
	ITEM(HttpHeaderAcceptEncoding),
	ITEM(HttpHeaderAcceptLanguage),
	ITEM(HttpHeaderAuthorization),
	ITEM(HttpHeaderCookie),
	ITEM(HttpHeaderExpect),
	ITEM(HttpHeaderFrom),
	ITEM(HttpHeaderHost),
	ITEM(HttpHeaderIfMatch),
	ITEM(HttpHeaderIfModifiedSince),
	ITEM(HttpHeaderIfNoneMatch),
	ITEM(HttpHeaderIfRange),
	ITEM(HttpHeaderIfUnmodifiedSince),
	ITEM(HttpHeaderMaxForwards),
	ITEM(HttpHeaderProxyAuthorization),
	ITEM(HttpHeaderReferer),
	ITEM(HttpHeaderRange),
	ITEM(HttpHeaderTe),
	ITEM(HttpHeaderTranslate),
	ITEM(HttpHeaderUserAgent),
	ITEM(HttpHeaderRequestMaximum)
};

HTTP_HEADER_DESC gvResponseHeaderDesc[]={
	ITEM(HttpHeaderCacheControl),
	ITEM(HttpHeaderConnection),
	ITEM(HttpHeaderDate),
	ITEM(HttpHeaderKeepAlive),
	ITEM(HttpHeaderPragma),
	ITEM(HttpHeaderTrailer),
	ITEM(HttpHeaderTransferEncoding),
	ITEM(HttpHeaderUpgrade),
	ITEM(HttpHeaderVia),
	ITEM(HttpHeaderWarning),
	ITEM(HttpHeaderAllow),
	ITEM(HttpHeaderContentLength),
	ITEM(HttpHeaderContentType),
	ITEM(HttpHeaderContentEncoding),
	ITEM(HttpHeaderContentLanguage),
	ITEM(HttpHeaderContentLocation),
	ITEM(HttpHeaderContentMd5),
	ITEM(HttpHeaderContentRange),
	ITEM(HttpHeaderExpires),
	ITEM(HttpHeaderLastModified),
	ITEM(HttpHeaderAcceptRanges),
	ITEM(HttpHeaderAge),
	ITEM(HttpHeaderEtag),
	ITEM(HttpHeaderLocation),
	ITEM(HttpHeaderProxyAuthenticate),
	ITEM(HttpHeaderRetryAfter),
	ITEM(HttpHeaderServer),
	ITEM(HttpHeaderSetCookie),
	ITEM(HttpHeaderVary),
	ITEM(HttpHeaderWwwAuthenticate),
	ITEM(HttpHeaderResponseMaximum)
};

void InitialOverlappedex(OVERLAPPEDEX* pOverlappedex)
{
	ZeroMemory(pOverlappedex,sizeof(OVERLAPPEDEX));
	pOverlappedex->HttpRequestId=HTTP_NULL_ID;
	pOverlappedex->IOType=ClientIORead;
	pOverlappedex->hFile=INVALID_HANDLE_VALUE;
}

void _parse_http_request(HTTP_REQUEST* pHttpRequest)
{
	USES_CONVERSION;
	int headerCount = sizeof(gvRequestHeaderDesc) / sizeof(HTTP_HEADER_DESC);
	CHAR buffer[MAX_PATH];
	for (int i=0;i<headerCount;i++)
	{
		int HeaderID=gvRequestHeaderDesc[i].id;
		if (pHttpRequest->Headers.KnownHeaders[HeaderID].RawValueLength!=0)
		{
			ZeroMemory(buffer,MAX_PATH);
			memcpy_s(buffer,MAX_PATH,pHttpRequest->Headers.KnownHeaders[HeaderID].pRawValue,pHttpRequest->Headers.KnownHeaders[HeaderID].RawValueLength);
			cout<<T2A(gvRequestHeaderDesc[i].desc)<<":"<<buffer<<endl;
		}
	}
}

std::wstring get_response_xml()
{
	std::wstring xml=L"<person><name>毕向阳</name></person>";
	return xml;
}

void _send_http_response_xml(HTTP_REQUEST* HttpRequest,HANDLE ReqQueueHandle, BOOL bAnsyc)
{
	HTTP_RESPONSE HttpResponse;
	//call ZeroMemory is required, or HttpSendHttpResponse returns ERROR_INVALID_PARAMETER
	ZeroMemory(&HttpResponse,sizeof(HTTP_RESPONSE));
	PCSTR Reason="OK";
	HttpResponse.StatusCode=200;
	HttpResponse.pReason=Reason;
	HttpResponse.ReasonLength=strlen(Reason);

	ADD_KNOWN_HEADER(HttpResponse,HttpHeaderContentType,"text/xml;charset=utf-8");

	std::wstring xml = get_response_xml();
	std::string strbuf = CW2AEX<256>(xml.c_str(),CP_UTF8);

	HTTP_DATA_CHUNK dataChunk[2];
	dataChunk[0].DataChunkType           = HttpDataChunkFromMemory;
	dataChunk[0].FromMemory.pBuffer      = (PVOID)strbuf.c_str();
	dataChunk[0].FromMemory.BufferLength = strbuf.length();
	//dataChunk[1].DataChunkType           = HttpDataChunkFromMemory;
	//dataChunk[1].FromMemory.pBuffer      = (PVOID)xml.c_str();
	//dataChunk[1].FromMemory.BufferLength = xml.length();

	HttpResponse.EntityChunkCount         = 1;
	HttpResponse.pEntityChunks            = dataChunk;

	PHTTP_LOG_FIELDS_DATA pLogFieldsData=NULL;
	HTTP_LOG_FIELDS_DATA LogFieldsData;
	//call ZeroMemory is required, or HttpSendHttpResponse returns ERROR_INVALID_PARAMETER
	ZeroMemory(&LogFieldsData,sizeof(HTTP_LOG_FIELDS_DATA));

	OSVERSIONINFO osversion = {0};
	osversion.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
	if (GetVersionEx(&osversion))
	{
		//windows vista and later
		if (osversion.dwMajorVersion >= 6)
		{
			LogFieldsData.Base.Type=HttpLogDataTypeFields;
			LogFieldsData.ClientIp="127.0.0.1";
			LogFieldsData.ClientIpLength=strlen("127.0.0.1");
			pLogFieldsData=&LogFieldsData;
		}
	}

	if (!bAnsyc)
	{
		ULONG BytesSent;
		ULONG result = HttpSendHttpResponse(
			ReqQueueHandle,     // ReqQueueHandle
			HttpRequest->RequestId,   // Request ID
			0,       // Flags
			&HttpResponse,           // HTTP response
			NULL,                // pReserved1
			&BytesSent,          // bytes sent  (OPTIONAL)
			NULL,                // pReserved2  (must be NULL)
			0,                   // Reserved3   (must be 0)
			NULL,                // LPOVERLAPPED(OPTIONAL)
			(PHTTP_LOG_DATA)pLogFieldsData                 // pReserved4  (must be NULL)
			); 

		if(result != NO_ERROR)
		{
			wprintf(L"HttpSendHttpResponse failed with %lu \n", result);
		}
	}
	else
	{
		OVERLAPPEDEX* pOverlapped = new OVERLAPPEDEX();
		InitialOverlappedex(pOverlapped);
		pOverlapped->IOType=ClientIOWrite;
		ULONG result = HttpSendHttpResponse(
			ReqQueueHandle,     // ReqQueueHandle
			HttpRequest->RequestId,   // Request ID
			0,       // Flags
			&HttpResponse,           // HTTP response
			NULL,      // pReserved1
			NULL,      // bytes sent  (OPTIONAL)
			NULL,      // pReserved2  (must be NULL)
			0,       // Reserved3   (must be 0)
			pOverlapped,                // LPOVERLAPPED(OPTIONAL)
			(PHTTP_LOG_DATA)pLogFieldsData       // pReserved4  (must be NULL)
			); 

		if(result != NO_ERROR && result!=ERROR_IO_PENDING)
		{
			wprintf(L"HttpSendHttpResponse failed with %lu \n", result);
		}
	}
}
void _send_http_response_file(HTTP_REQUEST* HttpRequest,HANDLE ReqQueueHandle, BOOL bAnsyc)
{
	HTTP_RESPONSE HttpResponse;
	//call ZeroMemory is required, or HttpSendHttpResponse returns ERROR_INVALID_PARAMETER
	ZeroMemory(&HttpResponse,sizeof(HTTP_RESPONSE));
	PCSTR Reason="OK";
	HttpResponse.StatusCode=200;
	HttpResponse.pReason=Reason;
	HttpResponse.ReasonLength=strlen(Reason);

	ADD_KNOWN_HEADER(HttpResponse,HttpHeaderContentType,"text/xml;charset=utf-8");

	std::wstring xml = get_response_xml();
	std::string strbuf = CW2AEX<256>(xml.c_str(),CP_UTF8);

	HTTP_DATA_CHUNK dataChunk[2];
	dataChunk[0].DataChunkType           = HttpDataChunkFromFragmentCache;
	dataChunk[0].FromFragmentCache.pFragmentName = L"https://+:8089/Topsec";
	dataChunk[0].FromFragmentCache.FragmentNameLength = wcslen(L"https://+:8089/Topsec") * 2;
	HttpResponse.EntityChunkCount         = 1;
	HttpResponse.pEntityChunks            = dataChunk;

	OVERLAPPEDEX* pOverlapped = new OVERLAPPEDEX();
	InitialOverlappedex(pOverlapped);
	pOverlapped->IOType=ClientIOWrite;

	ULONG result = HttpSendHttpResponse(
		ReqQueueHandle,     // ReqQueueHandle
		HttpRequest->RequestId,   // Request ID
		0,       // Flags
		&HttpResponse,           // HTTP response
		NULL,      // pReserved1
		NULL,      // bytes sent  (OPTIONAL)
		NULL,      // pReserved2  (must be NULL)
		0,       // Reserved3   (must be 0)
		pOverlapped,              // LPOVERLAPPED(OPTIONAL)
		NULL       // Windows Server 2003 and Windows XP with SP2:  This parameter is reserved and must be NULL.
		//Windows Vista and Windows Server 2008:  This parameter is new for Windows Vista, and Windows Server 2008
		); 
	if(result != NO_ERROR && result!=ERROR_IO_PENDING)
	{
		wprintf(L"HttpSendHttpResponse failed with %lu \n", result);
	}
}

void handle_http_request(HTTP_REQUEST* HttpRequest, HANDLE ReqQueueHandle)
{
	_parse_http_request(HttpRequest);
	if (_strcmpi("/topdesk",HttpRequest->pRawUrl) == 0)
	{
		_send_http_response_xml(HttpRequest, ReqQueueHandle,TRUE);
	}
	else if(_strcmpi("/topsec",HttpRequest->pRawUrl) == 0)
	{
		_send_http_response_file(HttpRequest, ReqQueueHandle,TRUE);
	}
}

unsigned int __stdcall _workthread(void *p)
{
	PTRDCONTEXT pTrdContext=(PTRDCONTEXT)p;
	DWORD NumberOfBytesTransferred;
	ULONG_PTR CompletionKey;
	LPOVERLAPPED pOverlapped;
	DWORD tid=GetCurrentThreadId();
	while (TRUE)
	{
		BOOL bOK=GetQueuedCompletionStatus(
			pTrdContext->hCompletionPort,
			&NumberOfBytesTransferred,
			&CompletionKey,
			&pOverlapped,
			5000);
		if (bOK)
		{
			if (pOverlapped!=NULL)
			{
				OVERLAPPEDEX* pOverlappedex=(OVERLAPPEDEX*)pOverlapped;
				if (pOverlappedex->IOType==ClientIORead)
				{
					handle_http_request((HTTP_REQUEST*)pOverlappedex->buffer, pTrdContext->ReqQueueHandle);InitialOverlappedex(pOverlappedex);HttpReceiveHttpRequest(pTrdContext->ReqQueueHandle,pOverlappedex->HttpRequestId,0,(PHTTP_REQUEST)pOverlappedex->buffer,BUFFERLEN,NULL,pOverlappedex);
				}
				else
				{
					cout<<"send response successfully"<<endl;
					delete pOverlappedex;
				}
			}
			else
			{
				if (CompletionKey==CK_EXIT)
				{
					cout<<"thread "<<tid<<" exit."<<endl;
					break;
				}
			}
		}
	}
	return 0;
}

CStringW GetLoggingDirectory()
{
	WCHAR buffer[MAX_PATH];
	GetModuleFileName(NULL,buffer,MAX_PATH);
	CStringW strFilename=buffer;
	int index=strFilename.ReverseFind(_T('\\'));
	return strFilename.Left(index);
}

int _tmain(int argc, _TCHAR* argv[])
{
	HTTPAPI_VERSION HttpApiVersion=HTTPAPI_VERSION_2;
	ULONG ul;
	ul=HttpInitialize(HttpApiVersion,HTTP_INITIALIZE_CONFIG|HTTP_INITIALIZE_SERVER,NULL);
	assert(ul==NO_ERROR);
	CHECKRETUL(ul);

	HTTP_SERVER_SESSION_ID ServerSessionID;
	ul=HttpCreateServerSession(HttpApiVersion,&ServerSessionID,0);
	assert(ul==NO_ERROR);
	CHECKRETUL(ul);

	//enable logging
	CStringW strLogDir = GetLoggingDirectory();
	HTTP_LOGGING_INFO LogginInfo;
	ZeroMemory(&LogginInfo,sizeof(HTTP_LOGGING_INFO));
	LogginInfo.Flags.Present=1;
	LogginInfo.Format=HttpLoggingTypeW3C;
	LogginInfo.Fields=HTTP_LOG_FIELD_TIME|HTTP_LOG_FIELD_CLIENT_IP;
	LogginInfo.DirectoryName=(LPCWSTR)strLogDir;
	LogginInfo.DirectoryNameLength=strLogDir.GetLength()*2;
	LogginInfo.RolloverType=HttpLoggingRolloverDaily;
	ul=HttpSetServerSessionProperty(ServerSessionID,HttpServerLoggingProperty,&LogginInfo,sizeof(HTTP_LOGGING_INFO));
	assert(ul==NO_ERROR);
	CHECKRETUL(ul);

	HTTP_URL_GROUP_ID UrlGroupID;
	ul=HttpCreateUrlGroup(ServerSessionID,&UrlGroupID,0);
	assert(ul==NO_ERROR);
	CHECKRETUL(ul);

	HTTP_URL_CONTEXT UrlContext=0;
	LPCWSTR TopdeskQualifiedUrl=L"http://+:8088/Topdesk";
	ul=HttpAddUrlToUrlGroup(UrlGroupID,TopdeskQualifiedUrl,UrlContext,0);
	assert(ul==NO_ERROR);
	CHECKRETUL(ul);

	LPCWSTR TopsecQualifiedUrl=L"https://+:8089/Topsec";
	ul=HttpAddUrlToUrlGroup(UrlGroupID,TopsecQualifiedUrl,UrlContext,0);
	assert(ul==NO_ERROR);
	CHECKRETUL(ul);

	HANDLE ReqQueueHandle;
	ul=HttpCreateRequestQueue(HttpApiVersion,NULL,NULL,0,&ReqQueueHandle);
	assert(ul==NO_ERROR);
	CHECKRETUL(ul);

	HTTP_BINDING_INFO Binding;
	Binding.Flags.Present=1;
	Binding.RequestQueueHandle=ReqQueueHandle;
	ul=HttpSetUrlGroupProperty(UrlGroupID,HttpServerBindingProperty,&Binding,sizeof(HTTP_BINDING_INFO));
	assert(ul==NO_ERROR);
	CHECKRETUL(ul);

	std::wstring xml = get_response_xml();
	std::string strbuf = CW2AEX<256>(xml.c_str(),CP_UTF8);
	HTTP_DATA_CHUNK cacheChunk;
	cacheChunk.DataChunkType           = HttpDataChunkFromMemory;
	cacheChunk.FromMemory.pBuffer      = (PVOID)strbuf.c_str();
	cacheChunk.FromMemory.BufferLength = strbuf.length();
	HTTP_CACHE_POLICY CachePolicy;
	CachePolicy.Policy=HttpCachePolicyTimeToLive;
	CachePolicy.SecondsToLive=1000*60;
	ul=HttpAddFragmentToCache(ReqQueueHandle,L"https://+:8089/Topsec",&cacheChunk,&CachePolicy,NULL);
	assert(ul==NO_ERROR);
	CHECKRETUL(ul);

	HANDLE hCompletionPort=CreateIoCompletionPort(INVALID_HANDLE_VALUE,NULL,CPK,0);
	HANDLE hNewCompletionPort=CreateIoCompletionPort(ReqQueueHandle,hCompletionPort,CPK,0);
	assert(hCompletionPort==hNewCompletionPort);
	HANDLE hTread[TRDCOUNT];
	for (int i=0;i<TRDCOUNT;i++)
	{
		PTRDCONTEXT trdContext = new TRDCONTEXT();
		trdContext->hCompletionPort=hCompletionPort;
		trdContext->ReqQueueHandle=ReqQueueHandle;
		hTread[i]=(HANDLE)_beginthreadex(NULL,0,_workthread,trdContext,0,NULL);
	}
	OVERLAPPEDEX* pOverlappedex=new OVERLAPPEDEX[TRDCOUNT];
	for (int i=0;i<TRDCOUNT;i++)
	{
		InitialOverlappedex(pOverlappedex+i);
		ul=HttpReceiveHttpRequest(
			ReqQueueHandle,
			pOverlappedex->HttpRequestId,
			0, //Only the request headers are retrieved; the entity body is not copied.
			(PHTTP_REQUEST)pOverlappedex->buffer,
			BUFFERLEN,
			NULL,
			pOverlappedex);
		assert(ul==NO_ERROR || ul==ERROR_IO_PENDING);
	}

	cout<<"Press any key to exit."<<endl;
	_getch();

	for(int i=0;i<TRDCOUNT;i++)
	{
		PostQueuedCompletionStatus(hCompletionPort,0,CK_EXIT,0);
	}

	DWORD dwRet=WaitForMultipleObjects(TRDCOUNT,hTread,TRUE,INFINITE);
	cout<<"WaitForMultipleObjects returned, code = "<<dwRet<<endl;

	HttpRemoveUrlFromUrlGroup(UrlGroupID,TopdeskQualifiedUrl,0);
	HttpRemoveUrlFromUrlGroup(UrlGroupID,TopsecQualifiedUrl,0);
	//or HttpRemoveUrlFromUrlGroup(UrlGroupID,NULL,HTTP_URL_FLAG_REMOVE_ALL);

	HttpCloseUrlGroup(UrlGroupID);
	HttpCloseServerSession(ServerSessionID);
	HttpCloseRequestQueue(ReqQueueHandle);
	HttpTerminate(HTTP_INITIALIZE_CONFIG|HTTP_INITIALIZE_SERVER,NULL);

	return 0;
}

xbgprogrammer
关注
perl use HTTP::Server::Simple 轻量级 http server
belldeep的专栏
06-08 597
perl use HTTP::Server::Simple 启动一个轻量级 http server
ESP32的HttpServer服务器
最新发布
zxz_Fine的博客
06-04 2103
ESP32的httpserver
基于boost.asio库的C++http/https web server
07-27
该c++ web server基于boost.asio库编写，同时支持http和https协议。该工程基于vs2015编译通过，相关配置和说明见readme.txt
一个简单的http server的例子
仅做个人笔记
02-12 389
摘自：https://blog.youkuaiyun.com/weixin_43851310/article/details/88067629（仅做个人备份，浏览请看原文 package main import ( "fmt" "net/http" ) func main() { //注册回调函数 http.HandleFunc("/hello", handler) //绑定tcp...
ACE6.2.0下载HTTP服务器文件
weixin_34128839的博客
10-26 185
#include "ace/Log_Msg.h" // ACE_DEBUG的宏定义在这里.#include "ace/OS.h"#include "ace/CDR_Stream.h"#include "ace/INET_Addr.h"#include "ace/SOCK_Connector.h"#include "ace/SOCK_Stream.h"#include "ace/streams.h"...
WPF项目创建HTTP WEB服务，不使用IIS业务 WPF桌面程序WebApi WPF 集成WebApi C# 创建HTTP Web API服务
weijia3624的专栏
12-27 2571
【代码】WPF项目创建HTTP WEB服务，不使用IIS业务 WPF桌面程序WebApi WPF 集成WebApi C# 创建HTTP Web API服务，
2 C++ ACE 基本IO对象 TCP/UDP/HTTP的Server/Client 组播广播
weixin_33851604的博客
10-31 517
2 C++ ACE 基本IO对象 TCP/UDP/HTTP的Server/Client 组播广播ACEI/O相关对象 阻塞式TCP连接LinuxKernel网站服务器的443端口 非阻塞模式TCP连接百度服务器 设置TCP连接超时: ACE客户端TCP模式.请求HTTP 一个简单的TCPHTTPserver HTTPserver代码...
VC网络通讯实现：UDP与WEBserver样例解析
在本样例中，WEB服务器需要能够响应HTTP请求并返回网页内容。 #### WEB服务器实现要点： 1. 监听端口：服务器需要监听一个端口，通常是80端口，等待客户端（如浏览器）的HTTP请求。 2. 接收请求：当收到HTTP请求时...
Synopse mORMot框架样例学习04 - HTTP Client-Server
loloopop的专栏
10-22 1322
例04展示的是HTTP客户端/服务器的数据库应用.这个示例里边有4个工程,Project04Client.dpr和Project04Server.dpr是一组客户端/服务端数据库示例,这个和例03基本差不多,区别是例04应用的是HTTP协议(例03应用的是命名管道),客户端和服务器通过约定的端口进行通讯,并且例04的主单元Unit2.pas中数据库初始化的时候加上了用户验证表的创建: DB :...
Zynq 7000裸机的lwip 样例程序echo server 实验
热门推荐
曾立文的博客
10-12 2万+
zynq 7000 裸机跑lwip 的echo server
写一个http的request和response
strawberry sweet
05-13 494
参考: https://nodejs.org/dist/latest-v12 新建文件夹Toy-Browser以及两正在上传…重新上传取消个内部文件
微软服务器应用软件,HTTP 服务器示例应用程序
weixin_32373123的博客
07-31 278
HTTP 服务器示例应用程序05/31/2018本文内容下面的示例应用程序演示如何使用 HTTP 服务器 API 来执行服务器端任务。 第一个示例中包含的 "precomp" 文件包括运行示例所需的所有标头，例如：#ifndef UNICODE#define UNICODE#endif#ifndef _WIN32_WINNT#define _WIN32_WINNT 0x0600#endif#ifn...
C发送http请求
hehe_heh的博客
05-11 9514
#include &lt;stdio.h&gt; #include &lt;string.h&gt; #include &lt;sys/socket.h&gt; #include &lt;arpa/inet.h&gt; #include &lt;unistd.h&gt; #include &lt;netinet/in.h&gt; #include &lt;stdlib.h&
http服务器API
日积月累
12-12 1727
 本文转载自：http://msdn.microsoft.com/zh-cn/magazine/aa364640(en-us,VS.85).aspx HTTP Server Sample Application The following sample application shows how to use the HTTP Server API to perform
原来C++调用HTTP API接口也能这么优雅
weixin_40603938的博客
07-25 5270
原来C++调用HTTP API接口也能这么优雅 动机 ​ 在开发C++程序时，难免会遇到与其他语言/系统对接的情况。百度谷歌搜了一下，发现star最高的cpp-httplib。试了一下，真香！关键这个库还是header only 引用的，这个超级Nice！！从此以后再也不担心跨语言对接了（手动滑稽）。 本文仅作抛砖引玉~ 一：cpp-httplib简介 一个header-only且跨平台的C++ HTTP/HTTPS库 只需将***httplib.h***包含到你的工程中即可完成配置（header-onl
vscode的i18n Ally插件无法翻译的解决方案
qq_33256701的博客
03-20 1905
然后就可以成功翻译了。
http，api接口相关知识点
putrember的博客
08-22 4594
httpHTTP协议的基本知识方法请求响应![请添加图片描述](https://img-blog.csdnimg.cn/f69ae3118f5545b3adb751ad30e38fc9.png)消息的交互测试 工具开发Requests库简介fiddler的使用（抓包）手机抓包 HTTP协议的基本知识 **介绍：**全程超文本传输协议，用来在浏览器和服务器上来传输超文本信息，后来发展到服务器与服务器之间，app和服务器都有使用 **特点：**通讯双方分文客户端和服务端，目前所有HTTP协议是基于TCP协议的，
使用C++ REST SDK开发简单的Web(HTTP)服务
weixin_33720452的博客
12-24 2998
C++ REST SDK是微软开源的一套客户端-服务器通信库，提供了URI构造/解析，JSON编解码，HTTP客户端、HTTP服务端，WebSocket客户端，流式传输，oAuth验证等C++类，方便C++语言编写的客户端程序访问互联网服务。其中HTTP服务端相关的类是最近新增的(尚处于beta测试阶段)，这些类拓展了C++ REST SDK的功能，现在不仅能开发客户端程序，...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值