Main Page | Modules | Alphabetical List | Data Structures | Directories | File List | Data Fields | Globals | Related Pages
src / lib

lib/misc.c File Reference

Detailed Description

Miscellaneous functions.

Author:
Raphael Manfredi
Date:
2001-2003

#include "common.h"
#include "atoms.h"
#include "base32.h"
#include "endian.h"
#include "eval.h"
#include "html_entities.h"
#include "misc.h"
#include "glib-missing.h"
#include "sha1.h"
#include "tm.h"
#include "walloc.h"
#include "utf8.h"
#include "override.h"

Defines

#define srandom(x)   srand(x)
#define random()   rand()
#define RANDOM_MASK   0xffffffff
#define RANDOM_MAXV   RAND_MAX
#define GENERATE_FILESIZE_PER_X(base)
#define TM_YEAR_BASE   1900
#define GENERATE_PARSE_UNSIGNED(NAME, TYPE)
#define GENERATE_PARSE_UINTX(bits)   GENERATE_PARSE_UNSIGNED(CAT2(parse_uint,bits), CAT2(guint,bits))
#define REPLACE(x)   { *len = CONST_STRLEN(x); return (x); }

Functions

size_t strlcpy (gchar *dst, const gchar *src, size_t dst_size)
 Needs to be defined if we are not using Glib 2.
size_t strlcat (gchar *dst, const gchar *src, size_t dst_size)
size_t concat_strings (gchar *dst, size_t size, const gchar *s,...)
 Concatenates a variable number of NUL-terminated strings into ``dst''.
size_t w_concat_strings (gchar **dst_ptr, const gchar *first,...)
 Concatenates a variable number of NUL-terminated strings into buffer which will be allocated using walloc().
gchar * is_strprefix (const gchar *str, const gchar *prefix)
 Checks whether ``prefix'' is a prefix of ``str''.
gchar * is_strcaseprefix (const gchar *str, const gchar *prefix)
 Checks whether ``prefix'' is a prefix of ``str'' performing an case-insensitive (ASCII only) check.
gboolean file_exists (const gchar *pathname)
 Check for file existence.
gboolean file_does_not_exist (const gchar *pathname)
 Check for file non-existence.
size_t print_uint16_hex (gchar *dst, guint16 v)
 Prints the unsigned 16-bit value ``v'' in hexadecimal presentation as NUL-terminated string to ``dst'' and returns the length of the resulting string.
guchar dec_digit (guchar x)
 Converts an integer to a single decimal ASCII digit.
size_t ipv4_to_string_buf (guint32 ipv4, gchar *dst, size_t size)
 Converts an IPv4 address in host-endian order to a string.
size_t ipv6_to_string_buf (const uint8_t *ipv6, gchar *dst, size_t size)
 Prints the IPv6 address ``ipv6'' to ``dst''.
const gchar * ipv6_to_string (const guint8 *ipv6)
 Prints the IPv6 address ``ipv6'' to a static buffer.
const gchar * ip_to_string (guint32 ip)
const gchar * hostname_port_to_string (const gchar *hostname, guint16 port)
guint32 string_to_ip (const gchar *s)
gboolean parse_ipv6_addr (const gchar *s, guint8 *dst, const gchar **endptr)
 Parses an IPv6 address.
gboolean string_to_ip_strict (const gchar *s, guint32 *addr, const gchar **endptr)
 A strict string to IP address conversion; when other stuff from misc.[ch] is not sufficient.
gboolean string_to_ip_port (const gchar *s, guint32 *ip_ptr, guint16 *port_ptr)
 Decompiles ip:port into ip and port.
const gchar * local_hostname (void)
size_t str_chomp (gchar *str, size_t len)
 Remove antepenultimate char of string if it is a "\r" followed by "\n".
gchar * absolute_pathname (const char *file)
 Create an absolute path.
gboolean is_absolute_path (const char *pathname)
 Check whether path is an absolute path.
gboolean is_directory (const gchar *pathname)
 Check whether path is a directory.
gboolean is_regular (const gchar *pathname)
 Check whether path points to a regular file.
gboolean is_symlink (const gchar *pathname)
 Check whether path is a symbolic link.
gint seek_to_filepos (gint fd, filesize_t pos)
 A wrapper around lseek() for handling filesize_t to off_t conversion.
guint filesize_fraction (filesize_t size, filesize_t part, guint base)
guint kilo (gboolean metric)
const gchar * byte_suffix (gboolean metric)
const gchar * scale_prefixes (gboolean metric)
gchar size_scale (guint64 v, guint *q, guint *r, const gchar *s, gboolean metric)
 Scales v so that quotient and reminder are both in the range "0..1023".
gchar norm_size_scale (guint64 v, guint *q, guint *r, gboolean metric)
gchar kib_size_scale (guint64 v, guint *q, guint *r, gboolean metric)
 Same as norm_size_scale_base2() but assumes v is already divided by 1024 (binary).
const gchar * short_size (guint64 size, gboolean metric)
const gchar * short_html_size (guint64 size, gboolean metric)
 Like short_size() but with unbreakable space between the digits and unit.
const gchar * short_kb_size (guint64 size, gboolean metric)
const gchar * compact_kb_size (guint32 size, gboolean metric)
gchar * compact_value (gchar *buf, size_t size, guint64 v, gboolean metric)
gchar * short_value (gchar *buf, size_t size, guint64 v, gboolean metric)
const gchar * compact_size (guint64 size, gboolean metric)
const gchar * compact_rate (guint64 rate, gboolean metric)
size_t short_rate_to_string_buf (guint64 rate, gboolean metric, gchar *dst, size_t size)
short_string_t short_rate_get_string (guint64 rate, gboolean metric)
const gchar * short_rate (guint64 rate, gboolean metric)
const gchar * short_time (time_delta_t t)
const gchar * short_time_ascii (time_delta_t t)
const gchar * compact_time (time_delta_t t)
 A variant of short_time_ascii() without whitespace.
const gchar * short_uptime (time_delta_t uptime)
 Alternate time formatter for uptime.
size_t guid_to_string_buf (const gchar *guid, gchar *dst, size_t size)
const gchar * guid_to_string (const gchar *guid)
const gchar * guid_hex_str (const gchar *guid)
gchar * data_hex_str (const gchar *data, size_t len)
gint hex2int (guchar c)
 Converts a hexadecimal char (0-9, A-F, a-f) to an integer.
gint dec2int (guchar c)
 Converts a decimal char (0-9) to an integer.
gint alnum2int (guchar c)
 Converts an alphanumeric char (0-9, A-Z, a-z) to an integer.
void hex2int_init (void)
 Initializes the lookup table for hex2int().
void dec2int_init (void)
 Initializes the lookup table for dec2int().
void alnum2int_init (void)
 Initializes the lookup table for alnum2int().
gboolean hex_to_guid (const gchar *hexguid, gchar *guid)
 Converts hexadecimal string into a GUID.
gchar * guid_base32_str (const gchar *guid)
 Converts GUID into its base32 representation, without the trailing padding.
gchar * base32_to_guid (const gchar *base32)
 Decode the base32 representation of a GUID.
gchar * sha1_to_base32_buf (const struct sha1 *sha1, gchar *dst, size_t size)
 Convert binary SHA1 into a base32 string.
const gchar * sha1_base32 (const struct sha1 *sha1)
 Convert binary SHA1 into a base32 string.
const gchar * sha1_to_string (const struct sha1 sha1)
size_t sha1_to_urn_string_buf (const struct sha1 *sha1, gchar *dst, size_t size)
 Convert binary SHA1 into a urn:sha1:<base32> string.
const gchar * sha1_to_urn_string (const struct sha1 *sha1)
const gchar * bitprint_to_urn_string (const struct sha1 *sha1, const struct tth *tth)
const struct sha1 * base32_sha1 (const gchar *base32)
 Convert base32 string into binary SHA1.
const gchar * tth_base32 (const struct tth *tth)
 Convert binary TTH into a base32 string.
const struct tth * base32_tth (const gchar *base32)
 Convert base32 string into a binary TTH.
const gchar * timestamp_utc_to_string (time_t date)
 Convert time to an ISO 8601 timestamp, e.g.
size_t timestamp_to_string_buf (time_t date, gchar *dst, size_t size)
 Convert time to ISO 8601 date plus time, e.g.
short_string_t timestamp_get_string (time_t date)
const gchar * timestamp_to_string (time_t date)
 Convert time to ISO 8601 date plus time, e.g.
size_t time_locale_to_string_buf (time_t t, gchar *dst, size_t size)
 Convert time (without the date) to a human-readable string using the time representation of the current locale.
gint tm_diff (const struct tm *a, const struct tm *b)
 Compute the difference in seconds between two tm structs (a - b).
size_t timestamp_rfc822_to_string_buf (time_t date, gchar *buf, size_t size)
 Convert time to RFC-822 style date, into supplied string buffer.
const gchar * timestamp_rfc822_to_string (time_t date)
 Convert time to RFC-822 style date.
const gchar * timestamp_rfc822_to_string2 (time_t date)
 Same as date_to_rfc822_gchar(), to be able to use the two in the same printf() line.
size_t timestamp_rfc1123_to_string_buf (time_t date, gchar *buf, size_t size)
 Convert time to RFC-1123 style date, into supplied string buffer.
const gchar * timestamp_rfc1123_to_string (time_t date)
 Convert time to RFC-1123 style date.
guint32 next_pow2 (guint32 n)
gint highest_bit_set (guint32 n)
 Determine the highest bit set in `n', -1 if value was 0.
gfloat force_range (gfloat val, gfloat min, gfloat max)
 Enforce range boundaries on a given floating point number.
guint32 random_value (guint32 max)
guint32 random_raw (void)
void sha1_feed_ulong (SHA1Context *ctx, gulong value)
void sha1_feed_double (SHA1Context *ctx, gdouble value)
void sha1_feed_pointer (SHA1Context *ctx, gconstpointer p)
void sha1_feed_string (SHA1Context *ctx, const gchar *s)
void random_init (void)
 Initialize random number generator.
gboolean is_printable (const gchar *buf, gint len)
 Check whether buffer contains printable data, suitable for "%s" printing.
void dump_hex_line (FILE *out, const gchar *data, size_t length, size_t offset)
 Prints a single "dump hex" line which consists of 16 byte from data.
void dump_hex (FILE *out, const gchar *title, gconstpointer data, gint length)
 Displays hex & ascii lines to the terminal (for debug) Displays the "title" then the characters in "s", # of bytes to print in "b".
void locale_strlower (gchar *dst, const gchar *src)
 Copies ``src'' to ``dst'', converting all upper-case characters to lower-case.
void ascii_strlower (gchar *dst, const gchar *src)
 Copies ``src'' to ``dst'', converting all ASCII upper-case characters to ASCII lower-case.
gint ascii_strcasecmp (const gchar *s1, const gchar *s2)
 Same as strcasecmp() but only case-insensitive for ASCII characters.
gint ascii_strncasecmp (const gchar *s1, const gchar *s2, size_t len)
 Same as strncasecmp() but only case-insensitive for ASCII characters.
gchar * ascii_strcasestr (const gchar *haystack, const gchar *needle)
 Same as strstr() but case-insensitive with respect to ASCII characters.
gint strcmp_delimit_full (const gchar *a, const gchar *b, const gchar *delimitors, gboolean case_sensitive)
 Compare two strings up to the specified delimiters.
gint strcmp_delimit (const gchar *a, const gchar *b, const gchar *delimit)
 Compare two strings case-senstive up to the specified delimiters.
gint ascii_strcasecmp_delimit (const gchar *a, const gchar *b, const gchar *delimit)
 Compare two strings case-insensitive up to the specified delimiters.
void guid_random_fill (gchar *xuid)
 Generate a new random GUID within given `xuid'.
size_t filename_shrink (const gchar *filename, gchar *buf, size_t size)
 Shrinks a filename so that it fits into the given buffer.
gchar * unique_pathname (const gchar *path, const gchar *filename, gboolean(*name_is_uniq)(const gchar *pathname))
size_t utf8_truncate (const gchar *src, gchar *dst, size_t size)
 Copies a string into a buffer whereas the string is potentially truncated but the UTF-8 encoding is preserved.
gchar * unique_filename (const gchar *path, const gchar *name, const gchar *ext, gboolean(*name_is_uniq)(const gchar *pathname))
 Determine unique filename for `file' in `path', with optional trailing extension `ext'.
gboolean char_is_space (guchar c)
 Allow spaces, tabs or new-lines as "spacing" chars.
gboolean char_is_safe (guchar c, gboolean strict)
 Nearly the same as isprint() but allows additional safe chars if !strict.
gchar * hex_escape (const gchar *name, gboolean strict)
 Escape all non-printable chars into the hexadecimal "\xhh" form.
gboolean escape_control_char (guchar c)
 Checks whether the given character is a control character that should be escaped.
gchar * control_escape (const gchar *s)
 Escape all ASCII control chars except LF into the hexadecimal "\xhh" form.
guint char_to_printf_escape (guchar c, gchar *esc, const char *safe_chars)
const gchar * lazy_string_to_printf_escape (const gchar *src)
 Escapes a string so that it can be used careless with the POSIX printf tool.
gboolean string_to_ip_and_mask (const gchar *str, guint32 *ip, guint32 *netmask)
 Extracts the IP address into `ip' and the netmask into `netmask'.
gint do_stat (const gchar *path, struct stat *buf)
 Wrapper for the stat() system call.
gchar * make_pathname (const gchar *dir, const gchar *file)
 Create new pathname from the concatenation of the dirname and the basename of the file.
gchar * short_filename (gchar *fullname)
 Determine stripped down path, removing SRC_PREFIX if present.
gint create_directory (const gchar *dir, mode_t mode)
 Creates the given directory including sub-directories if necessary.
const gchar * filepath_basename (const gchar *pathname)
 Returns a pointer to the basename of the given pathname.
const gchar * filepath_directory_end (const gchar *pathname, gchar separator)
gchar * filepath_directory (const gchar *pathname)
 Creates a copy with the given pathname with the basename cut off.
gboolean filepath_exists (const gchar *dir, const gchar *file)
 Check whether file given by its dirname and its basename exists.
size_t reverse_strlcpy (gchar *const dst, size_t size, const gchar *src, size_t src_len)
 Copies "src_len" chars from "src" to "dst" reversing their order.
size_t uint32_to_string_buf (guint32 v, gchar *dst, size_t size)
size_t uint64_to_string_buf (guint64 v, gchar *dst, size_t size)
size_t off_t_to_string_buf (off_t v, gchar *dst, size_t size)
size_t time_t_to_string_buf (time_t v, gchar *dst, size_t size)
const gchar * uint32_to_string (guint32 v)
const gchar * uint64_to_string (guint64 v)
const gchar * uint64_to_string2 (guint64 v)
const gchar * filesize_to_string (filesize_t v)
const gchar * off_t_to_string (off_t v)
const gchar * time_t_to_string (time_t v)
gint parse_major_minor (const gchar *src, gchar const **endptr, guint *major, guint *minor)
guint8 find_common_leading (guint32 ip1, guint32 ip2)
 Find amount of common leading bits between two IP addresses.
void ip_range_split (guint32 lower_ip, guint32 upper_ip, cidr_split_t cb, gpointer udata)
 Computes the set of CIDR ranges that make up the set of IPs between two boundary IPs, included.
signal_handler_t set_signal (gint signo, signal_handler_t handler)
 Installs a signal handler.
const gchar * html_escape_replacement (gchar c, size_t *len)
size_t html_escape (const gchar *src, gchar *dst, size_t dst_size)
 Copies the NUL-terminated string ``src'' to ``dst'' replacing all characters which are reserved in HTML with a replacement string.
guint32 html_decode_entity (const gchar *src, const gchar **endptr)
gint canonize_path (gchar *dst, const gchar *path)
 Creates the canonical representation of a path.
guint compat_max_fd (void)
gint compat_mkdir (const gchar *path, mode_t mode)
gboolean compat_is_superuser (void)
int compat_daemonize (const char *directory)
 Daemonizes the current process.
void compat_fadvise_sequential (int fd, off_t offset, off_t size)
size_t memcmp_diff (const void *a, const void *b, size_t size)
 Counts the number of bytes that differ between two chunks of memory.
guint32 cpu_noise (void)
gchar * normalize_dir_separators (const gchar *s)
 Creates a string copy with all directory separators replaced with the canonic path component separator '/' (a slash).
void set_close_on_exec (gint fd)
void close_file_descriptors (const int first_fd)
 Closes all file descriptors greater or equal to ``first_fd''.
void * compat_memmem (const void *data, size_t data_size, const void *pattern, size_t pattern_size)
 Equivalent to strstr() for raw memory without NUL-termination.
gboolean need_get_non_stdio_fd (void)
int get_non_stdio_fd (int fd)
 If we detect that stdio cannot handle file descriptors above 255, this functions tries to reassign 'fd' to a file descriptor above 255 in order to reserve lower file descriptors for stdio.
void misc_init (void)

Variables

const char hex_alphabet [] = "0123456789ABCDEF"
const char hex_alphabet_lower [] = "0123456789abcdef"
gint8 char2int_tabs [3][(size_t)(guchar)-1+1]
const gint8 * hex2int_tab = char2int_tabs[0]
const gint8 * dec2int_tab = char2int_tabs[1]
const gint8 * alnum2int_tab = char2int_tabs[2]
const gchar days [7][4]
const gchar months [12][4]
const gchar escape_char = '\\'
gint do_errno

Define Documentation

#define GENERATE_FILESIZE_PER_X (  base   ) 
 

Value:

guint \
filesize_per_ ## base (filesize_t size, filesize_t part) \
{ \
    return filesize_fraction(size, part, base); \
}

#define GENERATE_PARSE_UINTX (  bits   )     GENERATE_PARSE_UNSIGNED(CAT2(parse_uint,bits), CAT2(guint,bits))
 

#define GENERATE_PARSE_UNSIGNED (  NAME,
TYPE   ) 
 

 
#define random (   )     rand()
 

#define RANDOM_MASK   0xffffffff
 

#define RANDOM_MAXV   RAND_MAX
 

#define REPLACE (  x   )     { *len = CONST_STRLEN(x); return (x); }
 

#define srandom (  x   )     srand(x)
 

#define TM_YEAR_BASE   1900
 

Function Documentation

gchar* absolute_pathname (  const char *  file  ) 
 

Create an absolute path.

gint alnum2int (  guchar  c  ) 
 

Converts an alphanumeric char (0-9, A-Z, a-z) to an integer.

Passing a character which is not an alphanumeric ASCII character causes an assertion failure.

Parameters:
c the decimal ASCII character to convert.
Returns:
"0..36" for valid decimal ASCII characters.

void alnum2int_init (  void   )  [static]
 

Initializes the lookup table for alnum2int().

gint ascii_strcasecmp (  const gchar *  s1,
const gchar *  s2
) 
 

Same as strcasecmp() but only case-insensitive for ASCII characters.

gint ascii_strcasecmp_delimit (  const gchar *  a,
const gchar *  b,
const gchar *  delimit
) 
 

Compare two strings case-insensitive up to the specified delimiters.

gchar* ascii_strcasestr (  const gchar *  haystack,
const gchar *  needle
) 
 

Same as strstr() but case-insensitive with respect to ASCII characters.

void ascii_strlower (  gchar *  dst,
const gchar *  src
) 
 

Copies ``src'' to ``dst'', converting all ASCII upper-case characters to ASCII lower-case.

``dst'' and ``src'' may be identical but must not overlap otherwise.

gint ascii_strncasecmp (  const gchar *  s1,
const gchar *  s2,
size_t  len
) 
 

Same as strncasecmp() but only case-insensitive for ASCII characters.

const struct sha1* base32_sha1 (  const gchar *  base32  ) 
 

Convert base32 string into binary SHA1.

Parameters:
base32 a buffer holding SHA1_BASE32_SIZE or more bytes.
Returns:
Returns pointer to static data or NULL if the input wasn't a validly base32 encoded SHA1.

gchar* base32_to_guid (  const gchar *  base32  ) 
 

Decode the base32 representation of a GUID.

Returns:
pointer to static data, or NULL if the input was not valid base32.

const struct tth* base32_tth (  const gchar *  base32  ) 
 

Convert base32 string into a binary TTH.

Parameters:
base32 a buffer holding TTH_BASE32_SIZE or more bytes.
Returns:
Returns pointer to static data or NULL if the input wasn't a validly base32 encoded TTH.

const gchar* bitprint_to_urn_string (  const struct sha1 *  sha1,
const struct tth *  tth
) 
 

const gchar* byte_suffix (  gboolean  metric  )  [inline, static]
 

gint canonize_path (  gchar *  dst,
const gchar *  path
) 
 

Creates the canonical representation of a path.

``dst'' and ``src'' may be identical but must not overlap otherwise.

Parameters:
dst the destination, must be sufficiently long.
path a NUL-terminated string representing the input path.
Returns:
zero on sucess, non-zero on failure.

TODO: Add overlap check.

gboolean char_is_safe (  guchar  c,
gboolean  strict
)  [inline, static]
 

Nearly the same as isprint() but allows additional safe chars if !strict.

gboolean char_is_space (  guchar  c  )  [inline, static]
 

Allow spaces, tabs or new-lines as "spacing" chars.

guint char_to_printf_escape (  guchar  c,
gchar *  esc,
const char *  safe_chars
)  [static]
 

void close_file_descriptors (  const int  first_fd  ) 
 

Closes all file descriptors greater or equal to ``first_fd''.

const gchar* compact_kb_size (  guint32  size,
gboolean  metric
) 
 

Returns:
a number of Kbytes in a compact readable form

const gchar* compact_rate (  guint64  rate,
gboolean  metric
) 
 

const gchar* compact_size (  guint64  size,
gboolean  metric
) 
 

const gchar* compact_time (  time_delta_t  t  ) 
 

A variant of short_time_ascii() without whitespace.

Returns:
time spent in seconds in a consise short readable form.
Note:
The returned string is in English and ASCII encoded.

gchar* compact_value (  gchar *  buf,
size_t  size,
guint64  v,
gboolean  metric
) 
 

int compat_daemonize (  const char *  directory  ) 
 

Daemonizes the current process.

Parameters:
directory We will chdir() to this directory. A value of NULL implies the root directory.

void compat_fadvise_sequential (  int  fd,
off_t  offset,
off_t  size
) 
 

gboolean compat_is_superuser (  void   ) 
 

guint compat_max_fd (  void   ) 
 

void* compat_memmem (  const void *  data,
size_t  data_size,
const void *  pattern,
size_t  pattern_size
) 
 

Equivalent to strstr() for raw memory without NUL-termination.

Parameters:
data The memory to scan.
data_size The length of data.
pattern The byte pattern to look for.
pattern_size The length of the pattern.
Returns:
NULL if not found. Otherwise, the start address of the first match is returned.

gint compat_mkdir (  const gchar *  path,
mode_t  mode
) 
 

size_t concat_strings (  gchar *  dst,
size_t  size,
const gchar *  s,
  ...
) 
 

Concatenates a variable number of NUL-terminated strings into ``dst''.

The resulting string will be NUL-terminated unless ``size'' is zero. The returned value is the length of the resulting string if ``dst'' had been large enough. If the returned value is equal to or greater than ``size'' the string is truncated. If ``size'' is zero, ``dst'' may be NULL to calculate the resulting string length.

The list of strings must be terminated by a NULL pointer. The first list element may be NULL in which case zero is returned.

Parameters:
dst the destination buffer.
size the number of bytes ``dst'' can hold.
s the first source string or NULL.
Returns:
the sum of the lengths of all passed strings.

gchar* control_escape (  const gchar *  s  ) 
 

Escape all ASCII control chars except LF into the hexadecimal "\xhh" form.

When a CR LF sequence is seen, the CR character is dropped.

Returns:
new escaped string, or the original string if no escaping occurred.

guint32 cpu_noise (  void   ) 
 

gint create_directory (  const gchar *  dir,
mode_t  mode
) 
 

Creates the given directory including sub-directories if necessary.

The path must be absolute.

Parameters:
dir the pathname of the directory to create.
Returns:
On success, zero is returned. On failure, -1 is returned and errno indicates the reason.

gchar* data_hex_str (  const gchar *  data,
size_t  len
) 
 

Returns:
hexadecimal string representation of "small" binary buffer.
Note:
Buffer must be less than 40 chars, or only the first 40 chars are represented with a trailing "..." added to show it is incomplete.

gint dec2int (  guchar  c  ) 
 

Converts a decimal char (0-9) to an integer.

Passing a character which is not a decimal ASCII character causes an assertion failure.

Parameters:
c the decimal ASCII character to convert.
Returns:
"0..9" for valid decimal ASCII characters.

void dec2int_init (  void   )  [static]
 

Initializes the lookup table for dec2int().

guchar dec_digit (  guchar  x  )  [inline, static]
 

Converts an integer to a single decimal ASCII digit.

The are no checks, this is just a convenience function.

Parameters:
x An integer between 0 and 9.
Returns:
The ASCII character corresponding to the decimal digit [0-9].

gint do_stat (  const gchar *  path,
struct stat *  buf
) 
 

Wrapper for the stat() system call.

void dump_hex (  FILE *  out,
const gchar *  title,
gconstpointer  data,
gint  length
) 
 

Displays hex & ascii lines to the terminal (for debug) Displays the "title" then the characters in "s", # of bytes to print in "b".

void dump_hex_line (  FILE *  out,
const gchar *  data,
size_t  length,
size_t  offset
)  [static]
 

Prints a single "dump hex" line which consists of 16 byte from data.

Parameters:
out The stream to print the string at.
data A pointer to the first byte of the data to dump.
length The length of data in bytes.
offset The offset in data to start dumping at.

gboolean escape_control_char (  guchar  c  )  [inline, static]
 

Checks whether the given character is a control character that should be escaped.

Returns:
TRUE if "c" should be escaped, FALSE otherwise.

gboolean file_does_not_exist (  const gchar *  pathname  ) 
 

Check for file non-existence.

gboolean file_exists (  const gchar *  pathname  ) 
 

Check for file existence.

size_t filename_shrink (  const gchar *  filename,
gchar *  buf,
size_t  size
) 
 

Shrinks a filename so that it fits into the given buffer.

The function tries to preserve the filename extension if there is any. The UTF-8 encoding is also preserved.

Returns:
The length of the resulting filename.

const gchar* filepath_basename (  const gchar *  pathname  ) 
 

Returns a pointer to the basename of the given pathname.

A slash is always considered a separator but G_DIR_SEPARATOR is considered as well. Thus "/whatever/blah\\yadda" returns a pointer to yadda iff G_DIR_SEPARATOR is a backslash and otherwise points to "blah[...]".

Parameters:
pathname A pathname to extract basename from. This may be a relative path or just a basename.
Returns:
A pointer to the basename of "pathname". The pointer points into the buffer holding pathname.

gchar* filepath_directory (  const gchar *  pathname  ) 
 

Creates a copy with the given pathname with the basename cut off.

A slash is always considered a separator but G_DIR_SEPARATOR is considered as well. Thus "/whatever/blah\\yadda" returns "/whatever/blah" if G_DIR_SEPARATOR is a backslash, otherwise "/whatever" is returned.

Returns:
A newly allocated string holding the given pathname with the basename cut off. If the string contained no directory separator, NULL is returned.

const gchar* filepath_directory_end (  const gchar *  pathname,
gchar  separator
)  [static]
 

gboolean filepath_exists (  const gchar *  dir,
const gchar *  file
) 
 

Check whether file given by its dirname and its basename exists.

guint filesize_fraction (  filesize_t  size,
filesize_t  part,
guint  base
)  [inline, static]
 

Use integer arithmetic because float or double might be too small for 64-bit values.

const gchar* filesize_to_string (  filesize_t  v  ) 
 

guint8 find_common_leading (  guint32  ip1,
guint32  ip2
)  [static]
 

Find amount of common leading bits between two IP addresses.

gfloat force_range (  gfloat  val,
gfloat  min,
gfloat  max
) 
 

Enforce range boundaries on a given floating point number.

Parameters:
val The value to force within the range.
min The minimum value which val can be.
max The maximum value with val can be.
Returns:
The new value of val which will be between min and max.

int get_non_stdio_fd (  int  fd  ) 
 

If we detect that stdio cannot handle file descriptors above 255, this functions tries to reassign 'fd' to a file descriptor above 255 in order to reserve lower file descriptors for stdio.

File descriptors below 3 or above 255 are returned as-is. The original file descriptor is closed if it was reassigned. On systems which do not need this workaround, the original file descriptor is returned.

Note:
The FD_CLOEXEC flag set will be cleared on the new file descriptor if the file descriptor is successfully reassigned.
Returns:
On success a new file descriptor above 255 is returned. On failure or if reassigning was not necessary the original file descriptor is returned.

gchar* guid_base32_str (  const gchar *  guid  ) 
 

Converts GUID into its base32 representation, without the trailing padding.

Returns:
pointer to static data.

const gchar* guid_hex_str (  const gchar *  guid  ) 
 

Returns:
hexadecimal string representing given GUID.

void guid_random_fill (  gchar *  xuid  ) 
 

Generate a new random GUID within given `xuid'.

const gchar* guid_to_string (  const gchar *  guid  ) 
 

size_t guid_to_string_buf (  const gchar *  guid,
gchar *  dst,
size_t  size
) 
 

gint hex2int (  guchar  c  ) 
 

Converts a hexadecimal char (0-9, A-F, a-f) to an integer.

Passing a character which is not a hexadecimal ASCII character causes an assertion failure.

Parameters:
c the hexadecimal ASCII character to convert.
Returns:
"0..15" for valid hexadecimal ASCII characters.

void hex2int_init (  void   )  [static]
 

Initializes the lookup table for hex2int().

gchar* hex_escape (  const gchar *  name,
gboolean  strict
) 
 

Escape all non-printable chars into the hexadecimal "\xhh" form.

Returns:
new escaped string, or the original string if no escaping occurred.

gboolean hex_to_guid (  const gchar *  hexguid,
gchar *  guid
) 
 

Converts hexadecimal string into a GUID.

Parameters:
hexguid the hexadecimal representation to convert
guid the 16-byte array into which the decoded GUID is written to
Returns:
TRUE if OK.

gint highest_bit_set (  guint32  n  ) 
 

Determine the highest bit set in `n', -1 if value was 0.

const gchar* hostname_port_to_string (  const gchar *  hostname,
guint16  port
) 
 

guint32 html_decode_entity (  const gchar *  src,
const gchar **  endptr
) 
 

size_t html_escape (  const gchar *  src,
gchar *  dst,
size_t  dst_size
) 
 

Copies the NUL-terminated string ``src'' to ``dst'' replacing all characters which are reserved in HTML with a replacement string.

Parameters:
src a NUL-terminated string.
dst the destination buffer, may be NULL if ``size'' is zero.
dst_size the size in bytes of the destination buffer.
Returns:
the length in bytes of resulting string assuming size was sufficiently large.

const gchar* html_escape_replacement (  gchar  c,
size_t *  len
)  [inline, static]
 

void ip_range_split (  guint32  lower_ip,
guint32  upper_ip,
cidr_split_t  cb,
gpointer  udata
) 
 

Computes the set of CIDR ranges that make up the set of IPs between two boundary IPs, included.

For instance, for the range 2.0.0.0 - 2.138.24.150, we have:

2.0.0.0/9, 2.128.0.0/13, 2.136.0.0/15, 2.138.0.0/20, 2.138.16.0/21, 2.138.24.0/25, 2.138.24.128/28, 2.138.24.144/30, 2.138.24.148, 2.138.24.149 and 2.138.24.150.

For each identified CIDR range, invoke the supplied callback, along with the trailing user-supplied `udata' pointer.

Parameters:
lower_ip the lower-bound IP
upper_ip the upper-bound IP
cb the callback, invoked as callback(ip, bits, udata)
udata the trailing parameter passed as-is to the callbacks

const gchar* ip_to_string (  guint32  ip  ) 
 

size_t ipv4_to_string_buf (  guint32  ipv4,
gchar *  dst,
size_t  size
) 
 

Converts an IPv4 address in host-endian order to a string.

Parameters:
ipv4 An 32-bit integer holding an IPv4 address in host-endian order.
dst The destination buffer to hold the resulting string.
size The size of the `dst' buffer in bytes. This should be IPV4_ADDR_BUFLEN or larger, otherwise the string will be truncated.
Returns:
The length of the resulting string assuming `size' was sufficiently large.

const gchar* ipv6_to_string (  const guint8 *  ipv6  ) 
 

Prints the IPv6 address ``ipv6'' to a static buffer.

Parameters:
ipv6 the IPv6 address; must point to a buffer of 16 bytes.
Returns:
a pointer to a static buffer holding a NUL-terminated string representing the given IPv6 address.

size_t ipv6_to_string_buf (  const uint8_t *  ipv6,
gchar *  dst,
size_t  size
) 
 

Prints the IPv6 address ``ipv6'' to ``dst''.

The string written to ``dst'' is always NUL-terminated unless ``size'' is zero. If ``size'' is too small, the string will be truncated.

Parameters:
dst the destination buffer; may be NULL iff ``size'' is zero.
ipv6 the IPv6 address; must point to a buffer of 16 bytes.
size the size of ``dst'' in bytes.
Returns:
The length of the resulting string assuming ``size'' is sufficient.

gboolean is_absolute_path (  const char *  pathname  ) 
 

Check whether path is an absolute path.

gboolean is_directory (  const gchar *  pathname  ) 
 

Check whether path is a directory.

gboolean is_printable (  const gchar *  buf,
gint  len
) 
 

Check whether buffer contains printable data, suitable for "%s" printing.

If not, consider dump_hex().

gboolean is_regular (  const gchar *  pathname  ) 
 

Check whether path points to a regular file.

gchar* is_strcaseprefix (  const gchar *  str,
const gchar *  prefix
) 
 

Checks whether ``prefix'' is a prefix of ``str'' performing an case-insensitive (ASCII only) check.

Maybe skip_caseprefix() would be a better name.

Parameters:
str a NUL-terminated string
prefix a NUL-terminated string
Returns:
NULL, if ``prefix'' is not a prefix of ``str''. Otherwise, a pointer to the first character in ``str'' after the prefix.

gchar* is_strprefix (  const gchar *  str,
const gchar *  prefix
) 
 

Checks whether ``prefix'' is a prefix of ``str''.

Maybe skip_prefix() would be a better name.

Parameters:
str a NUL-terminated string
prefix a NUL-terminated string
Returns:
NULL, if ``prefix'' is not a prefix of ``str''. Otherwise, a pointer to the first character in ``str'' after the prefix.

gboolean is_symlink (  const gchar *  pathname  ) 
 

Check whether path is a symbolic link.

gchar kib_size_scale (  guint64  v,
guint *  q,
guint *  r,
gboolean  metric
)  [inline, static]
 

Same as norm_size_scale_base2() but assumes v is already divided by 1024 (binary).

guint kilo (  gboolean  metric  )  [inline, static]
 

const gchar* lazy_string_to_printf_escape (  const gchar *  src  ) 
 

Escapes a string so that it can be used careless with the POSIX printf tool.

Therefore it's absolutely paranoid and escapes everything but ASCII alphanumerics, dots, hyphen and underscores.

Note:
Hex sequences are always two digits long, so "\xAAA" is the same as "\xAA" "A". In C this not necessarily true and could be understood as a wide-char sequence.
Parameters:
src The string to escape.
Returns:
The escaped string. MUST NOT be freed.

const gchar* local_hostname (  void   ) 
 

Returns:
local host name, as pointer to static data.

void locale_strlower (  gchar *  dst,
const gchar *  src
) 
 

Copies ``src'' to ``dst'', converting all upper-case characters to lower-case.

``dst'' and ``src'' may point to the same object. The conversion depends on the current locale.

gchar* make_pathname (  const gchar *  dir,
const gchar *  file
) 
 

Create new pathname from the concatenation of the dirname and the basename of the file.

A directory separator is insert, unless "dir" already ends with one or "filename" starts with one.

Parameters:
dir The directory path.
file The filename.
Returns:
A newly allocated string.

size_t memcmp_diff (  const void *  a,
const void *  b,
size_t  size
) 
 

Counts the number of bytes that differ between two chunks of memory.

void misc_init (  void   ) 
 

gboolean need_get_non_stdio_fd (  void   )  [static]
 

guint32 next_pow2 (  guint32  n  ) 
 

Returns:
the closest power of two greater or equal to `n'. next_pow2(0) and next_pow2(0x8.......) return 0.

gchar norm_size_scale (  guint64  v,
guint *  q,
guint *  r,
gboolean  metric
)  [inline, static]
 

gchar* normalize_dir_separators (  const gchar *  s  ) 
 

Creates a string copy with all directory separators replaced with the canonic path component separator '/' (a slash).

Parameters:
s a pathname.
Returns:
a newly allocated string.

const gchar* off_t_to_string (  off_t  v  ) 
 

size_t off_t_to_string_buf (  off_t  v,
gchar *  dst,
size_t  size
) 
 

gboolean parse_ipv6_addr (  const gchar *  s,
guint8 *  dst,
const gchar **  endptr
) 
 

Parses an IPv6 address.

Parameters:
s the string to parse.
dst will hold the IPv6 address on success; must point to 16 or more bytes .
endptr if not NULL, it will point to the next character after the parsed address on success. On failure it will point to the character which caused the failure.
Returns:
FALSE if ``s'' is not a valid IPv6 address; TRUE on success.

gint parse_major_minor (  const gchar *  src,
gchar const **  endptr,
guint *  major,
guint *  minor
) 
 

size_t print_uint16_hex (  gchar *  dst,
guint16  v
)  [inline, static]
 

Prints the unsigned 16-bit value ``v'' in hexadecimal presentation as NUL-terminated string to ``dst'' and returns the length of the resulting string.

``dst'' must point to a buffer of 5 or more bytes.

Parameters:
dst the destination buffer.
v the 16-bit value.
Returns:
the length of resulting string.

void random_init (  void   ) 
 

Initialize random number generator.

guint32 random_raw (  void   ) 
 

Returns:
random value between (0..RAND_MAX).

guint32 random_value (  guint32  max  ) 
 

Returns:
random value between (0..max).

size_t reverse_strlcpy (  gchar *const   dst,
size_t  size,
const gchar *  src,
size_t  src_len
)  [inline, static]
 

Copies "src_len" chars from "src" to "dst" reversing their order.

The resulting string is always NUL-terminated unless "size" is zero. If "size" is not larger than "src_len", the resulting string will be truncated. NUL chars copied from "src" are not treated as string terminations.

Parameters:
dst The destination buffer.
size The size of the destination buffer.
src The source buffer.
src_len The size of the source buffer.
Returns:
The resulting length of string not counting the termating NUL. Note that NULs that might have been copied from "src" are included in this count. Thus strlen(dst) would return a lower value in this case.

const gchar* scale_prefixes (  gboolean  metric  )  [inline, static]
 

gint seek_to_filepos (  gint  fd,
filesize_t  pos
) 
 

A wrapper around lseek() for handling filesize_t to off_t conversion.

Parameters:
fd A valid file descriptor.
pos The position to seek to.
Returns:
0 on success and -1 on failure.

void set_close_on_exec (  gint  fd  ) 
 

signal_handler_t set_signal (  gint  signo,
signal_handler_t  handler
) 
 

Installs a signal handler.

The signal handler is not reset to the default handler after delivery. If the signal is SIGALRM, the handler is installed so that interrupted system calls fail with EINTR. Handlers for other all signals are installed so that interrupted system calls are restarted instead.

Parameters:
signo the signal number.
handler the signal handler to install.
Returns:
the previous signal handler or SIG_ERR on failure.

const gchar* sha1_base32 (  const struct sha1 *  sha1  ) 
 

Convert binary SHA1 into a base32 string.

Returns:
pointer to static data.

void sha1_feed_double (  SHA1Context *  ctx,
gdouble  value
)  [static]
 

void sha1_feed_pointer (  SHA1Context *  ctx,
gconstpointer  p
)  [static]
 

void sha1_feed_string (  SHA1Context *  ctx,
const gchar *  s
)  [static]
 

void sha1_feed_ulong (  SHA1Context *  ctx,
gulong  value
)  [static]
 

gchar* sha1_to_base32_buf (  const struct sha1 *  sha1,
gchar *  dst,
size_t  size
) 
 

Convert binary SHA1 into a base32 string.

Parameters:
dst The destination buffer for the string.
size The size of "dst" in bytes; should be larger than SHA1_BASE32_SIZE, otherwise the resulting string will be truncated.
Returns:
dst.

const gchar* sha1_to_string (  const struct sha1  sha1  ) 
 

const gchar* sha1_to_urn_string (  const struct sha1 *  sha1  ) 
 

size_t sha1_to_urn_string_buf (  const struct sha1 *  sha1,
gchar *  dst,
size_t  size
) 
 

Convert binary SHA1 into a urn:sha1:<base32> string.

Parameters:
sha1 A binary SHA-1.
Returns:
The SHA-1 converted to an URN string.

gchar* short_filename (  gchar *  fullname  ) 
 

Determine stripped down path, removing SRC_PREFIX if present.

Returns:
pointer within supplied string.

const gchar* short_html_size (  guint64  size,
gboolean  metric
) 
 

Like short_size() but with unbreakable space between the digits and unit.

const gchar* short_kb_size (  guint64  size,
gboolean  metric
) 
 

const gchar* short_rate (  guint64  rate,
gboolean  metric
) 
 

short_string_t short_rate_get_string (  guint64  rate,
gboolean  metric
) 
 

size_t short_rate_to_string_buf (  guint64  rate,
gboolean  metric,
gchar *  dst,
size_t  size
) 
 

const gchar* short_size (  guint64  size,
gboolean  metric
) 
 

const gchar* short_time (  time_delta_t  t  ) 
 

Returns:
time spent in seconds in a consise short readable form.
Note:
The returned string may be translated and non-ASCII.

const gchar* short_time_ascii (  time_delta_t  t  ) 
 

Returns:
time spent in seconds in a consise short readable form.
Note:
The returned string is in English and ASCII encoded.

const gchar* short_uptime (  time_delta_t  uptime  ) 
 

Alternate time formatter for uptime.

gchar* short_value (  gchar *  buf,
size_t  size,
guint64  v,
gboolean  metric
) 
 

gchar size_scale (  guint64  v,
guint *  q,
guint *  r,
const gchar *  s,
gboolean  metric
)  [inline, static]
 

Scales v so that quotient and reminder are both in the range "0..1023".

Parameters:
v no document.
q pointer to a guint; will hold the quotient.
r pointer to a guint; will hold the reminder.
s a string holding the scale prefixes; must be sufficiently long.
Returns:
the appropriate prefix character from "s".

size_t str_chomp (  gchar *  str,
size_t  len
) 
 

Remove antepenultimate char of string if it is a "\r" followed by "\n".

Remove final char of string if it is a "\n" or "\r". If len is 0, compute it.

Returns:
new string length.

gint strcmp_delimit (  const gchar *  a,
const gchar *  b,
const gchar *  delimit
) 
 

Compare two strings case-senstive up to the specified delimiters.

gint strcmp_delimit_full (  const gchar *  a,
const gchar *  b,
const gchar *  delimitors,
gboolean  case_sensitive
)  [static]
 

Compare two strings up to the specified delimiters.

guint32 string_to_ip (  const gchar *  s  ) 
 

Returns:
0 if ``s'' is not a valid IPv4 address. Otherwise, the parsed IPv4 address in host byte order.

gboolean string_to_ip_and_mask (  const gchar *  str,
guint32 *  ip,
guint32 *  netmask
) 
 

Extracts the IP address into `ip' and the netmask into `netmask'.

Returns:
whether the supplied string represents a valid ip/mask combination.
Accepted forms: "a.b.c.d" implies /32 "a.b.c.d/e" whereas e [1..32] "a.b.c.d/w.x.y.z"

If the IP address or the netmask is zero, the function will return FALSE.

gboolean string_to_ip_port (  const gchar *  s,
guint32 *  ip_ptr,
guint16 *  port_ptr
) 
 

Decompiles ip:port into ip and port.

Leading spaces are ignored.

Returns:
TRUE if it parsed correctly, FALSE otherwise.

gboolean string_to_ip_strict (  const gchar *  s,
guint32 *  addr,
const gchar **  endptr
) 
 

A strict string to IP address conversion; when other stuff from misc.[ch] is not sufficient.

Returns:
TRUE if ``s'' pointed to a string representation of an IPv4 address, otherwise FALSE.
If successful, ``*addr'' will be set to the IPv4 address in NATIVE byte order and ``*endptr'' will point to the character after the IPv4 address. ``addr'' and ``endptr'' may be NULL.

size_t strlcat (  gchar *  dst,
const gchar *  src,
size_t  dst_size
) 
 

size_t strlcpy (  gchar *  dst,
const gchar *  src,
size_t  dst_size
) 
 

Needs to be defined if we are not using Glib 2.

size_t time_locale_to_string_buf (  time_t  t,
gchar *  dst,
size_t  size
) 
 

Convert time (without the date) to a human-readable string using the time representation of the current locale.

Parameters:
t time to convert.
dst buffer to hold the resulting string.
size the size of the dst buffer.
Returns:
length of the created string.

const gchar* time_t_to_string (  time_t  v  ) 
 

size_t time_t_to_string_buf (  time_t  v,
gchar *  dst,
size_t  size
) 
 

short_string_t timestamp_get_string (  time_t  date  ) 
 

const gchar* timestamp_rfc1123_to_string (  time_t  date  ) 
 

Convert time to RFC-1123 style date.

Returns:
pointer to static data.

size_t timestamp_rfc1123_to_string_buf (  time_t  date,
gchar *  buf,
size_t  size
)  [static]
 

Convert time to RFC-1123 style date, into supplied string buffer.

Parameters:
date The timestamp.
buf The destination buffer to hold the resulting string. Must be greater than zero.
size The size of of "buf".
Returns:
The length of the created string.

const gchar* timestamp_rfc822_to_string (  time_t  date  ) 
 

Convert time to RFC-822 style date.

Returns:
pointer to static data.

const gchar* timestamp_rfc822_to_string2 (  time_t  date  ) 
 

Same as date_to_rfc822_gchar(), to be able to use the two in the same printf() line.

size_t timestamp_rfc822_to_string_buf (  time_t  date,
gchar *  buf,
size_t  size
)  [static]
 

Convert time to RFC-822 style date, into supplied string buffer.

Parameters:
date The timestamp.
buf The destination buffer to hold the resulting string. Must be greater than zero.
size The size of of "buf".
Returns:
The length of the created string.

const gchar* timestamp_to_string (  time_t  date  ) 
 

Convert time to ISO 8601 date plus time, e.g.

"2005-11-10 20:21:57".

Returns:
pointer to static data.

size_t timestamp_to_string_buf (  time_t  date,
gchar *  dst,
size_t  size
) 
 

Convert time to ISO 8601 date plus time, e.g.

"2002-06-09 14:54:42".

Returns:
The length of the created string.

const gchar* timestamp_utc_to_string (  time_t  date  ) 
 

Convert time to an ISO 8601 timestamp, e.g.

"2002-06-09T14:54:42Z".

Returns:
pointer to static data.

gint tm_diff (  const struct tm *  a,
const struct tm *  b
)  [static]
 

Compute the difference in seconds between two tm structs (a - b).

Comes from glibc-2.2.5.

const gchar* tth_base32 (  const struct tth *  tth  ) 
 

Convert binary TTH into a base32 string.

Returns:
pointer to static data.

const gchar* uint32_to_string (  guint32  v  ) 
 

size_t uint32_to_string_buf (  guint32  v,
gchar *  dst,
size_t  size
) 
 

const gchar* uint64_to_string (  guint64  v  ) 
 

const gchar* uint64_to_string2 (  guint64  v  ) 
 

size_t uint64_to_string_buf (  guint64  v,
gchar *  dst,
size_t  size
) 
 

gchar* unique_filename (  const gchar *  path,
const gchar *  name,
const gchar *  ext,
gboolean(*)(const gchar *pathname)  name_is_uniq
) 
 

Determine unique filename for `file' in `path', with optional trailing extension `ext'.

If no `ext' is wanted, one must supply an empty string.

Parameters:
path A directory path.
file The basename for the resulting pathname.
ext An optional filename extension to be appended to the basename.
name_is_uniq An optional callback to decide whether a created pathname is uniq. If omitted, the default is file_does_not_exist().
Returns:
the chosen unique complete filename as a pointer which must be freed.

NOTE: The generated filename must not exceed FILENAME_MAXBYTES because such a file cannot be created. In reality, it depends on the filesystem as well and the limit might be even smaller. In any case, we don't want to cut-off arbitrary bytes but at least preserve the filename extension and the (potential) UTF-8 encoding.

gchar* unique_pathname (  const gchar *  path,
const gchar *  filename,
gboolean(*)(const gchar *pathname)  name_is_uniq
)  [static]
 

size_t utf8_truncate (  const gchar *  src,
gchar *  dst,
size_t  size
)  [static]
 

Copies a string into a buffer whereas the string is potentially truncated but the UTF-8 encoding is preserved.

Parameters:
src The string to copy.
dst The destination buffer.
size The size of "dst" in bytes.
Returns:
The length of the truncated string in bytes.

size_t w_concat_strings (  gchar **  dst_ptr,
const gchar *  first,
  ...
) 
 

Concatenates a variable number of NUL-terminated strings into buffer which will be allocated using walloc().

The list of strings must be terminated by a NULL pointer. The first list element may be NULL in which case 1 is returned.

Parameters:
dst_ptr if not NULL, it will point to the allocated buffer.
first the first source string or NULL.
Returns:
The sum of the lengths of all passed strings plus 1 for the the trailing NUL. Use this as size argument for wfree() to release the allocated buffer.

Variable Documentation

const gint8* alnum2int_tab = char2int_tabs[2]
 

gint8 char2int_tabs[3][(size_t)(guchar)-1+1] [static]
 

const gchar days[7][4] [static]
 

Initial value:

    { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" }

const gint8* dec2int_tab = char2int_tabs[1]
 

gint do_errno
 

const gchar escape_char = '\\' [static]
 

const gint8* hex2int_tab = char2int_tabs[0]
 

const char hex_alphabet[] = "0123456789ABCDEF" [static]
 

const char hex_alphabet_lower[] = "0123456789abcdef"
 

const gchar months[12][4] [static]
 

Initial value:

 {
    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
}

Generated on Sat Jun 30 17:53:28 2007 for gtk-gnutella by  doxygen 1.3.9.1