DNSServer
#include<iostream>
#include<cstdio>
#include<cstring>
#include<ctime>
#include<cstdlib>
#include<netinet/in.h>
#include<sys/socket.h>
#include<unistd.h>
#include<arpa/inet.h>
using namespace std;
const static int dns_server_port = 53; // DNS服务器的端口，DNS协议标准端口为53
const static char* dns_server_ip = "114.114.114.114"; // DNS服务器的IP地址，这里使用了114DNS
struct dns_header {
unsigned short id; // 事务ID，用于标识查询的唯一性
unsigned short flags; // 标志位，用于控制查询的行为及响应的状态
unsigned short questions; // 问题计数，指示请求中包含的问题数
unsigned short answer; // 回答记录数，指示回答部分的DNS记录数
unsigned short authority; // 授权记录数，指示授权部分的DNS记录数
unsigned short additional; // 附加记录数，指示附加部分的DNS记录数
};
struct dns_question {
int length; // 查询名长度，用于指示查询名的字节长度
unsigned short qtype; // 查询类型，指出请求的资源记录类型，如A记录、MX记录等
unsigned short qclass; // 查询类别，通常是IN，表示Internet
unsigned char *name; // 查询名，表示请求解析的域名
};
int dns_create_header(dns_header *header){
if(header == nullptr){
return -1; // 错误处理：指针为空
}
srandom(time(nullptr));
header->id = random(); // 随机生成事务ID
header->flags = htons(0x0100); // 设置标志位为标准查询
header->questions = htons(1); // 设置问题计数为1
return 0;
}
int dns_create_question(dns_question *question, const char *domain) {
if (question == nullptr || domain == nullptr) {
return -1; // 错误处理：参数为空
}
question->qtype = htons(1); // Type A
question->qclass = htons(1); // Class IN
question->name = (unsigned char *)strdup(domain); // 复制域名
question->length = strlen(domain); // 设置查询名长度
// 将域名转换为DNS格式
unsigned char *dst = question->name;
const char *src = domain;
while (*src != '\0') {
unsigned char *len = dst++;
*len = 0;
while (*src != '\0' && *src != '.') {
*dst++ = *src++;
(*len)++;
}
if (*src == '.') {
src++;
}
}
*dst++ = 0; // 字符串结束
return 0;
}
int dns_build_requestion(dns_header *header, dns_question *question, char* request) {
if (header == nullptr || question == nullptr || request == nullptr) {
return -1; // 错误处理：指针为空
}
int offset = 0;
memcpy(request, header, sizeof(*header)); // 复制头部到请求
offset = sizeof(dns_header);
// 复制查询名到请求
memcpy(request + offset, question->name, question->length);
offset += question->length;
memcpy(request + offset, &question->qtype, sizeof(question->qtype));
offset += sizeof(question->qtype);
memcpy(request + offset, &question->qclass, sizeof(question->qclass));
offset += sizeof(question->qclass);
return offset; // 返回请求总长度
}
int dns_client_commit(const char* domain){
int sockfd = socket(AF_INET, SOCK_DGRAM, 0); // 创建UDP套接字
if(sockfd < 0) {
return -1; // 错误处理：套接字创建失败
}
struct sockaddr_in servaddr{};
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(dns_server_port);
servaddr.sin_addr.s_addr = inet_addr(dns_server_ip);
dns_header header{};
dns_create_header(&header); // 创建DNS查询头
dns_question question{};
if (dns_create_question(&question, domain) != 0) { // 创建DNS查询问题
close(sockfd); // 创建问题失败时，关闭套接字
return -1;
}
char request[1024]{};
int len = dns_build_requestion(&header, &question, request); // 构建DNS查询请求
// 发送DNS查询
sendto(sockfd, request, len, 0, (struct sockaddr*)&servaddr, sizeof(servaddr));
// 接收DNS响应
char response[1024]{};
struct sockaddr_in addr;
socklen_t addr_len = sizeof(struct sockaddr_in);
int n = recvfrom(sockfd, response, sizeof(response), 0, (struct sockaddr*)&addr, &addr_len);
printf("recvfrom:%d %s\n", n, response); // 打印接收到的字节数和响应内容
close(sockfd); // 关闭套接字
return 0;
HttpServer
#include<iostream>
#include<cstdio>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<unistd.h>
#include<cstdlib>
#include<cstring>
#include<string>
#include<netdb.h>
#include<sys/types.h>
#include<fcntl.h>
#include<vector>
using namespace std;
constexpr static int buffer_size=1024;
const static char* http_version="HTTP/1.1";
const static char* connection_type="connection:close\r\n";
char *host_to_ip(const char *hostname){
struct hostent *host_entry=gethostbyname(hostname);
if (host_entry) {
return inet_ntoa(*(struct in_addr*)host_entry->h_addr_list[0]);
}
return nullptr;
}
int http_create_socket(const char *ip){
int sockfd=socket(AF_INET,SOCK_STREAM,0);
struct sockaddr_in sin{};
sin.sin_family=AF_INET;
sin.sin_port=htons(80);
sin.sin_addr.s_addr=inet_addr(ip);
if(0!=connect(sockfd,(struct sockaddr*)&sin,sizeof(sockaddr_in))){
close(sockfd);
return -1;
}
fcntl(sockfd,F_SETFL,O_NONBLOCK);
return sockfd;
}
char* http_send_request(const char* hostname,const char* resource){
char *ip=host_to_ip(hostname);
int sockfd=http_create_socket(ip);
char buffer[buffer_size]{};
sprintf(buffer, "GET %s %s\r\nHost: %s\r\n%s\r\n", resource, http_version, hostname, connection_type);
send(sockfd,buffer,strlen(buffer),0);
//select
fd_set fdread;
FD_ZERO(&fdread);
FD_SET(sockfd,&fdread);
struct timeval tv;
tv.tv_sec=5;
tv.tv_usec=0;
vector<char>result;
while(1){
int selection=select(sockfd+1,&fdread,nullptr,nullptr,&tv);
if(!selection||FD_ISSET(sockfd,&fdread)){
break;
}
else{
char buffer[buffer_size]{};
int len=recv(sockfd,buffer,buffer_size,0);
if(len==0){
break;
}
result.insert(result.end(),buffer,buffer+len);
}
}
result.push_back('\0');
// 如果需要返回一个 C 风格的字符串，可以使用下面的代码将 vector 转换为字符串
result.push_back('\0'); // 确保有结束符
char* c_result = new char[result.size()];
std::memcpy(c_result, result.data(), result.size());
return c_result; // 注意：调用者负责释放这段内存
}
int main(){
const char* hostname = "httpbin.org";
const char* resource = "/get";
char* response = http_send_request(hostname, resource);
if (response) {
std::cout << "Received Response:\n" << response << std::endl;
delete[] response; // 释放内存
} else {
std::cerr << "Failed to get a response from the server." << std::endl;
}
return 0;
}
