Home | History | Annotate | Line # | Download | only in sldns
parseutil.h revision 1.1 
      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 arithmetics (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 arithmetics 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 */
    149