LCOV - code coverage report
Current view: top level - minipot/http - http_minipot_session_utils.c (source / functions) Hit Total Coverage
Test: sentinel-minipot-2.3.0 Code Coverage Lines: 0 56 0.0 %
Date: 2022-11-27 17:36:11 Functions: 0 10 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : #include "http_minipot_session_utils.h"
       2             : #include <minipot_utils.h>
       3             : #include <stdlib.h>
       4             : #include <string.h>
       5             : #include "log.h"
       6             : 
       7           0 : int check_method(uint8_t *method, size_t len) {
       8           0 :         MINIPOT_TRACE_FUNC;
       9           0 :         for (size_t i = 0; i < len; i++)
      10           0 :                 if (method[i] <= 32 || method[i] >= 127)
      11             :                         return -1;
      12             :         return 0;
      13             : }
      14             : 
      15           0 : int check_url(uint8_t *url, size_t len) {
      16           0 :         MINIPOT_TRACE_FUNC;
      17           0 :         for (size_t i = 0; i < len; i++)
      18           0 :                 if (url[i] <= 32 || url[i] == 127)
      19             :                         return -1;
      20             :         return 0;
      21             : }
      22             : 
      23           0 : int check_version(uint8_t *version, size_t len) {
      24           0 :         MINIPOT_TRACE_FUNC;
      25           0 :         if (len != 8
      26           0 :                         || strncmp(version, "HTTP/", strlen("HTTP/")) != 0
      27           0 :                         || version[5] < '0' || version[5] > '9'
      28           0 :                         || version[6] != '.'
      29           0 :                         || version[7] < '0' || version[7] > '9')
      30           0 :                 return -1;
      31             :         return 0;
      32             : }
      33             : 
      34           0 : int check_header_name(uint8_t *name, size_t len) {
      35           0 :         MINIPOT_TRACE_FUNC;
      36           0 :         for (size_t i = 0; i < len; i++)
      37           0 :                 if (name[i] <= 32 || name[i] >= 127
      38           0 :                                 || name[i] == 34 || name[i] == 40 || name[i] == 41
      39             :                                 || name[i] == 44 || name[i] == 47
      40             :                                 || (name[i] >= 58 && name[i] <= 64)
      41             :                                 || (name[i] >= 91 && name[i] <= 93)
      42             :                                 || name[i] == 123 || name[i] == 125)
      43             :                         return -1;
      44             :         return 0;
      45             : }
      46             : 
      47           0 : int check_header_val(uint8_t *val, size_t len) {
      48           0 :         MINIPOT_TRACE_FUNC;
      49           0 :         for (size_t i = 0; i < len; i++)
      50           0 :                 if ((val[i] <= 8) || (val[i] >= 10 && val[i] <= 31) || val[i] == 127)
      51             :                         return -1;
      52             :         return 0;
      53             : }
      54             : 
      55           0 : int check_chunk_size_ext(uint8_t *ext,  size_t len) {
      56           0 :         MINIPOT_TRACE_FUNC;
      57           0 :         for (size_t i = 0; i < len; i++)
      58           0 :                 if (ext[i] < 32 || ext[i] >= 127)
      59             :                         return -1;
      60             :         return 0;
      61             : }
      62             : 
      63           0 : char *time2str(time_t t) {
      64           0 :         MINIPOT_TRACE_FUNC;
      65             :         // WARNING: memory size is selected by manual counting of expect
      66             :         // characters from example output.
      67           0 :         char *ret = malloc(sizeof(*ret) * 32);
      68           0 :         if (!ret)
      69             :                 return NULL;
      70           0 :         strftime(ret, 64, "%a, %d %b %Y %T GMT", gmtime(&t));
      71           0 :         return ret;
      72             : }
      73             : 
      74           0 : size_t get_trail_ws_len(uint8_t *str, size_t len) {
      75           0 :         MINIPOT_TRACE_FUNC;
      76           0 :         size_t ws_len = 0;
      77           0 :         for (size_t i = 0; i < len; i++)
      78           0 :                 if (str[len - i - 1] != ' ' && str[len - i - 1] != '\t')
      79             :                         break;
      80             :                 else
      81           0 :                         ws_len++;
      82           0 :         return ws_len;
      83             : }
      84             : 
      85           0 : size_t get_prec_ws_len(uint8_t *str, size_t len) {
      86           0 :         MINIPOT_TRACE_FUNC;
      87           0 :         size_t ws_len = 0;
      88           0 :         for (size_t i = 0; i < len; i++)
      89           0 :                 if (str[i] != ' ' && str[i] != '\t')
      90             :                         break;
      91             :                 else
      92           0 :                         ws_len++;
      93           0 :         return ws_len;
      94             : }
      95             : 
      96           0 : void skip_bytes(int64_t *to_skip, const uint8_t **buff, size_t *bytes_to_proc) {
      97           0 :         MINIPOT_TRACE_FUNC;
      98           0 :         size_t diff = MINIPOT_MIN(*to_skip, *bytes_to_proc);
      99           0 :         *bytes_to_proc -= diff;
     100           0 :         *to_skip -= diff;
     101           0 :         *buff += diff;
     102           0 : }

Generated by: LCOV version 1.16