devbox
Gausst松鼠会
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

http网络服务器

作者：Gausst松鼠会 | 2024-06-17 15:12:10

赞

踩

http网络服务器

wwwroot(目录)/index.html

  1. <!DOCTYPE html>
  2. <html lang="en">
  3.  
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7.     <title>比特就业课</title>
  8. </head>
  9.  
  10. <body>
  11.     <h3>这是一个Linux课程</h3>
  12.     <p>我是一个Linux的学习者,我正在进行http的测试工作!!!</p>
  13. </body>
  14.  
  15. </html>

Makefile

  1. HttpServer:HttpServer.cc
  2. 	g++ -o HttpServer HttpServer.cc -std=c++11
  3.  
  4. .PHONY:clean
  5. clean:
  6. 	rm -f HttpServer

Log.hpp

  1. #pragma once
  2. #include <iostream>
  3. #include <string>
  4. #include <cstdarg>
  5. #include <cstdio>
  6. #include <ctime>
  7.  
  8. #define DEBUG 0
  9. #define NORMAL 1
  10. #define WARNING 2
  11. #define ERROR 3
  12. #define FATAL 4
  13.  
  14. const char *gLevelMap[5] = {"DEBUG", "NORMAL", "WARNING", "ERROR", "FATAL"};
  15.  
  16. #define LOGFILE "./threadpool.log"
  17.  
  18. void logMessage(int level, const char *format, ...)
  19. {
  20.     char stdBuffer[1024]; // 标准部分
  21.     time_t timestamp = time(nullptr);
  22.     struct tm *time = localtime(&timestamp);
  23.     snprintf(stdBuffer, sizeof stdBuffer, "[%s][%ld]", gLevelMap[level], timestamp);
  24.  
  25.     char logBuffer[1024]; // 自定义部分
  26.     va_list args;
  27.     va_start(args, format);
  28.     vsnprintf(logBuffer, sizeof(logBuffer), format, args); // 使用 vsnprintf 而不是 vsprintf
  29.     va_end(args);
  30.  
  31.     //FILE* fp=fopen(LOGFILE,"a");
  32.  
  33.     //打印到显示器
  34.     printf("%s %s\n", stdBuffer, logBuffer);
  35.  
  36.     // 打印到指定文件
  37.     //fprintf(fp,"%s%s\n",stdBuffer,logBuffer);
  38.  
  39.     //fclose(fp);
  40. }

Sock.hpp

  1. #pragma once
  2.  
  3. #include <iostream>
  4. #include <sys/types.h>
  5. #include <sys/socket.h>
  6. #include <string.h>
  7. #include <arpa/inet.h>
  8. #include <netinet/in.h>
  9. #include <string>
  10. #include <sys/wait.h>
  11.  
  12. #include "Log.hpp"
  13. #include <memory>
  14.  
  15. class Sock
  16. {
  17. private:
  18.     const static int gbacklog = 20;
  19.  
  20. public:
  21.     Sock() {}
  22.     int Socket()
  23.     {
  24.         int listensock = socket(AF_INET, SOCK_STREAM, 0);
  25.         if (listensock < 0)
  26.         {
  27.             logMessage(FATAL, "create socket error,%d:%s", errno, strerror(errno));
  28.             exit(2);
  29.         }
  30.         logMessage(NORMAL, "create socket success, listensock: %d", listensock);
  31.  
  32.         return listensock;
  33.     }
  34.  
  35.     void Bind(int sock, uint16_t port, std::string ip = "0.0.0.0")
  36.     {
  37.         struct sockaddr_in local;
  38.         memset(&local, 0, sizeof(local));
  39.         local.sin_family = AF_INET;
  40.         local.sin_port = htons(port);
  41.         inet_pton(AF_INET, ip.c_str(), &local.sin_addr);
  42.         // local.sin_addr.s_addr = _ip.empty() ? INADDR_ANY : inet_addr(_ip.c_str());
  43.         if (bind(sock, (const sockaddr *)&local, sizeof(local)) < 0)
  44.         {
  45.             logMessage(FATAL, "bind error, %d:%s", errno, strerror(errno));
  46.             exit(3);
  47.         }
  48.     }
  49.  
  50.     void Listen(int sock)
  51.     {
  52.  
  53.         if (listen(sock, gbacklog) < 0)
  54.         {
  55.             logMessage(FATAL, "listen error, %d:%s", errno, strerror(errno));
  56.             exit(4);
  57.         }
  58.         logMessage(NORMAL, "listen server success");
  59.     }
  60.  
  61.     int Accept(int listensock, std::string *ip, uint16_t *port)
  62.     {
  63.         struct sockaddr_in src;
  64.         memset(&src, 0, sizeof(src));
  65.         socklen_t len = sizeof(src);
  66.         int servicesock = accept(listensock, (struct sockaddr *)&src, &len);
  67.         if (servicesock < 0)
  68.         {
  69.             logMessage(ERROR, "accept error,%d:%s", errno, strerror(errno));
  70.             return -1;
  71.         }
  72.         if (port)
  73.             *port = ntohs(src.sin_port);
  74.         if (ip)
  75.             *ip = inet_ntoa(src.sin_addr);
  76.         return servicesock;
  77.     }
  78.  
  79.     bool Connect(int sock, const std::string &server_ip, const uint16_t &server_port)
  80.     {
  81.         struct sockaddr_in server;
  82.         memset(&server, 0, sizeof(server));
  83.         server.sin_family = AF_INET;
  84.         server.sin_port = htons(server_port);
  85.         server.sin_addr.s_addr = inet_addr(server_ip.c_str());
  86.  
  87.         if (connect(sock, (struct sockaddr *)&server, sizeof(server)) == 0)
  88.             return true;
  89.         else
  90.             return false;
  91.     }
  92.  
  93.     ~Sock()
  94.     {
  95.     }
  96. };

Usage.hpp

  1. #pragma once
  2. #include <iostream>
  3.  
  4. void Usage(const char *args)
  5. {
  6.     std::cout << "\nUsage: " << args << " port" << std::endl;
  7. }
  8.

Util.hpp

  1. #pragma once
  2.  
  3. #include <iostream>
  4. #include <vector>
  5.  
  6. class Util
  7. {
  8. public:
  9.     static void cutString(const std::string &s, const std::string &sep, std::vector<std::string> *out)
  10.     {
  11.         std::size_t start = 0;
  12.         while (start < s.size())
  13.         {
  14.             auto pos = s.find(sep, start);
  15.             if (pos == std::string::npos)
  16.             {
  17.                 break;
  18.             }
  19.             std::string sub = s.substr(start, pos - start);
  20.             out->push_back(sub);
  21.             start += sub.size();
  22.             start += sep.size();
  23.         }
  24.         if (start < s.size())
  25.             out->push_back(s.substr(start));
  26.     }
  27. };

HttpServer.hpp

  1. #pragma once
  2.  
  3. #include <iostream>
  4. #include "Sock.hpp"
  5. #include <functional>
  6. #include <unistd.h>
  7.  
  8. class HttpServer
  9. {
  10. public:
  11.     using func_t = std::function<void(int)>;
  12.  
  13. public:
  14.     HttpServer(uint16_t port, func_t func)
  15.         : _port(port), _func(func)
  16.     {
  17.         _listensock = sock.Socket();
  18.         sock.Bind(_listensock, _port);
  19.         sock.Listen(_listensock);
  20.     }
  21.  
  22.     void Start()
  23.     {
  24.         signal(SIGCHLD, SIG_IGN);
  25.         while (true)
  26.         {
  27.             std::string clientIp;
  28.             uint16_t clientPort;
  29.             int sockfd = sock.Accept(_listensock, &clientIp, &clientPort);
  30.             if (sockfd == -1)
  31.             {
  32.                 continue;
  33.             }
  34.             if (fork() == 0)
  35.             {
  36.                 close(_listensock);
  37.                 _func(sockfd);
  38.                 close(sockfd);
  39.                 exit(0);
  40.             }
  41.             close(sockfd);
  42.         }
  43.     }
  44.  
  45.     ~HttpServer()
  46.     {
  47.         if (_listensock >= 0)
  48.         {
  49.             close(_listensock);
  50.         }
  51.     }
  52.  
  53. private:
  54.     int _listensock;
  55.     uint16_t _port;
  56.     Sock sock;
  57.     func_t _func;
  58. };

HttpServer.cc

  1. #include <iostream>
  2. #include "HttpServer.hpp"
  3. #include <memory>
  4. #include "Usage.hpp"
  5. #include <unistd.h>
  6. #include "Util.hpp"
  7. #include <sys/types.h>
  8. #include <sys/stat.h>
  9. #include <fcntl.h>
  10. #include <fstream>
  11.  
  12. #define ROOT "./wwwroot"
  13. #define HOMEPAGE "index.html"
  14.  
  15. void HandlerHttpRequest(int sockfd)
  16. {
  17.     // 1.读取请求
  18.     char buffer[1024];
  19.     int s = read(sockfd, buffer, sizeof buffer);
  20.     if (s > 0)
  21.     {
  22.         buffer[s] = 0;
  23.         // std::cout << buffer << "--------------------" << std::endl;
  24.     }
  25.  
  26.     std::vector<std::string> vline;
  27.     Util::cutString(buffer, "\n", &vline);
  28.  
  29.     std::vector<std::string> vblock;
  30.     Util::cutString(vline[0], " ", &vblock);
  31.  
  32.     std::string file = vblock[1];
  33.     std::string target = ROOT;
  34.     
  35.     //默认首页
  36.     if (file == "/")
  37.         file = "/index.html";
  38.     target += file;
  39.     std::cout << target << std::endl;
  40.  
  41.     std::string content;
  42.     std::ifstream in(target);
  43.     if (in.is_open())
  44.     {
  45.         std::string line;
  46.         while (std::getline(in, line))
  47.         {
  48.             content += line;
  49.         }
  50.         in.close();
  51.     }
  52.  
  53.     // for (auto &iter : vblock)
  54.     // {
  55.     //     std::cout << iter << "\n"
  56.     //               << std::endl;
  57.     // }
  58.  
  59.     // 2.试着构建一个http的响应
  60.     std::string HttpResponse;
  61.     if (content.empty())
  62.     {
  63.         HttpResponse = "HTTP/1.1 404 NotFound\r\n";
  64.     }
  65.     else
  66.         HttpResponse = "HTTP/1.1 200 OK\r\n";
  67.     HttpResponse += "\r\n";
  68.     HttpResponse += content;
  69.     send(sockfd, HttpResponse.c_str(), HttpResponse.size(), 0);
  70. }
  71.  
  72. int main(int argc, char *argv[])
  73. {
  74.     if (argc != 2)
  75.     {
  76.         Usage(argv[0]);
  77.         exit(0);
  78.     }
  79.  
  80.     std::unique_ptr<HttpServer> httpserver(new HttpServer(atoi(argv[1]), HandlerHttpRequest));
  81.     httpserver->Start();
  82.     return 0;
  83. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/731698
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号