unbound/ldns/parseutil.h

   1 /*
   2  * parseutil.h - parse utilities for string and wire conversion
   3  *
   4  * (c) NLnet Labs, 2004
   5  *
   6  * See the file LICENSE for the license
   7  */
   8 /**
   9  * \file
  10  *
  11  * Utility functions for parsing, base32(DNS variant) and base64 encoding
  12  * and decoding, Hex, Time units, Escape codes.
  13  */
  14
  15 #ifndef LDNS_PARSEUTIL_H
  16 #define LDNS_PARSEUTIL_H
  17 struct tm;
  18
  19 /**
  20  *  A general purpose lookup table
  21  *
  22  *  Lookup tables are arrays of (id, name) pairs,
  23  *  So you can for instance lookup the RCODE 3, which is "NXDOMAIN",
  24  *  and vice versa. The lookup tables themselves are defined wherever needed,
  25  *  for instance in host2str.c
  26  */
  27 struct sldns_struct_lookup_table {
  28         int id;
  29         const char *name;
  30 };
  31 typedef struct sldns_struct_lookup_table sldns_lookup_table;
  32
  33 /**
  34  * Looks up the table entry by name, returns NULL if not found.
  35  * \param[in] table the lookup table to search in
  36  * \param[in] name what to search for
  37  * \return the item found
  38  */
  39 sldns_lookup_table *sldns_lookup_by_name(sldns_lookup_table table[],
  40                                        const char *name);
  41 /**
  42  * Looks up the table entry by id, returns NULL if not found.
  43  * \param[in] table the lookup table to search in
  44  * \param[in] id what to search for
  45  * \return the item found
  46  */
  47 sldns_lookup_table *sldns_lookup_by_id(sldns_lookup_table table[], int id);
  48
  49 /**
  50  * Convert TM to seconds since epoch (midnight, January 1st, 1970).
  51  * Like timegm(3), which is not always available.
  52  * \param[in] tm a struct tm* with the date
  53  * \return the seconds since epoch
  54  */
  55 time_t sldns_mktime_from_utc(const struct tm *tm);
  56
  57 /**
  58  * The function interprets time as the number of seconds since epoch
  59  * with respect to now using serial arithmitics (rfc1982).
  60  * That number of seconds is then converted to broken-out time information.
  61  * This is especially usefull when converting the inception and expiration
  62  * fields of RRSIG records.
  63  *
  64  * \param[in] time number of seconds since epoch (midnight, January 1st, 1970)
  65  *            to be intepreted as a serial arithmitics number relative to now.
  66  * \param[in] now number of seconds since epoch (midnight, January 1st, 1970)
  67  *            to which the time value is compared to determine the final value.
  68  * \param[out] result the struct with the broken-out time information
  69  * \return result on success or NULL on error
  70  */
  71 struct tm * sldns_serial_arithmitics_gmtime_r(int32_t time, time_t now, struct tm *result);
  72
  73 /**
  74  * converts a ttl value (like 5d2h) to a long.
  75  * \param[in] nptr the start of the string
  76  * \param[out] endptr points to the last char in case of error
  77  * \return the convert duration value
  78  */
  79 uint32_t sldns_str2period(const char *nptr, const char **endptr);
  80
  81 /**
  82  * Returns the int value of the given (hex) digit
  83  * \param[in] ch the hex char to convert
  84  * \return the converted decimal value
  85  */
  86 int sldns_hexdigit_to_int(char ch);
  87
  88 /**
  89  * calculates the size needed to store the result of b64_ntop
  90  */
  91 size_t sldns_b64_ntop_calculate_size(size_t srcsize);
  92
  93 int sldns_b64_ntop(uint8_t const *src, size_t srclength,
  94         char *target, size_t targsize);
  95
  96 /**
  97  * calculates the size needed to store the result of sldns_b64_pton
  98  */
  99 size_t sldns_b64_pton_calculate_size(size_t srcsize);
 100
 101 int sldns_b64_pton(char const *src, uint8_t *target, size_t targsize);
 102
 103 /**
 104  * calculates the size needed to store the result of b32_ntop
 105  */
 106 size_t sldns_b32_ntop_calculate_size(size_t src_data_length);
 107
 108 size_t sldns_b32_ntop_calculate_size_no_padding(size_t src_data_length);
 109
 110 int sldns_b32_ntop(const uint8_t* src_data, size_t src_data_length,
 111         char* target_text_buffer, size_t target_text_buffer_size);
 112
 113 int sldns_b32_ntop_extended_hex(const uint8_t* src_data, size_t src_data_length,
 114         char* target_text_buffer, size_t target_text_buffer_size);
 115
 116 /**
 117  * calculates the size needed to store the result of b32_pton
 118  */
 119 size_t sldns_b32_pton_calculate_size(size_t src_text_length);
 120
 121 int sldns_b32_pton(const char* src_text, size_t src_text_length,
 122         uint8_t* target_data_buffer, size_t target_data_buffer_size);
 123
 124 int sldns_b32_pton_extended_hex(const char* src_text, size_t src_text_length,
 125         uint8_t* target_data_buffer, size_t target_data_buffer_size);
 126
 127 /*
 128  * Checks whether the escaped value at **s is an octal value or
 129  * a 'normally' escaped character (and not eos)
 130  *
 131  * @param ch_p: the parsed character
 132  * @param str_p: the string. moved along for characters read.
 133  * The string pointer at *s is increased by either 0 (on error), 1 (on
 134  * normal escapes), or 3 (on octals)
 135  *
 136  * @return 0 on error
 137  */
 138 int sldns_parse_escape(uint8_t *ch_p, const char** str_p);
 139
 140 /**
 141  * Parse one character, with escape codes,
 142  * @param ch_p: the parsed character
 143  * @param str_p: the string. moved along for characters read.
 144  * @return 0 on error
 145  */
 146 int sldns_parse_char(uint8_t *ch_p, const char** str_p);
 147
 148 #endif /* LDNS_PARSEUTIL_H */