|#define||apr_killpg(x, y) (killpg ((x), (y)))|
|const char *||apr_filepath_name_get (const char *pathname)|
|const char *||apr_filename_of_pathname (const char *pathname)|
|int||apr_vformatter (int(*flush_func)(apr_vformatter_buff_t *b), apr_vformatter_buff_t *c, const char *fmt, va_list ap)|
|apr_status_t||apr_password_get (const char *prompt, char *pwbuf, apr_size_t *bufsize)|
|y||)||(killpg ((x), (y)))|
apr_killpg Small utility macros to make things easier to read. Not usually a goal, to be sure..
|#define HUGE_STRING_LEN 8192|
A constant representing a 'large' string.
|const char* apr_filename_of_pathname||(||const char *||pathname||)|
|const char* apr_filepath_name_get||(||const char *||pathname||)|
return the final element of the pathname
|pathname||The path to get the final element of|
For example: "/foo/bar/gum" -> "gum" "/foo/bar/gum/" -> "" "gum" -> "gum" "bs\\path\\stuff" -> "stuff"
|apr_status_t apr_password_get||(||const char *||prompt,|
Display a prompt and read in the password from stdin.
|prompt||The prompt to display|
|pwbuf||Buffer to store the password|
|bufsize||The length of the password buffer.|
|int apr_vformatter||(||int(*)(apr_vformatter_buff_t *b)||flush_func,|
|const char *||fmt,|
apr_vformatter() is a generic printf-style formatting routine with some extensions.
|flush_func||The function to call when the buffer is full|
|c||The buffer to write to|
|fmt||The format string|
|ap||The arguments to use to fill out the format string.|
The extensions are:
The %p hacks are to force gcc's printf warning code to skip over a pointer argument without complaining. This does mean that the ANSI-style %p (output a void * in hex format) won't work as expected at all, but that seems to be a fair trade-off for the increased robustness of having printf-warnings work.
Additionally, apr_vformatter allows for arbitrary output methods using the apr_vformatter_buff and flush_func.
The apr_vformatter_buff has two elements curpos and endpos. curpos is where apr_vformatter will write the next byte of output. It proceeds writing output to curpos, and updating curpos, until either the end of output is reached, or curpos == endpos (i.e. the buffer is full).
If the end of output is reached, apr_vformatter returns the number of bytes written.
When the buffer is full, the flush_func is called. The flush_func can return -1 to indicate that no further output should be attempted, and apr_vformatter will return immediately with -1. Otherwise the flush_func should flush the buffer in whatever manner is appropriate, re apr_pool_t nitialize curpos and endpos, and return 0.
Note that flush_func is only invoked as a result of attempting to write another byte at curpos when curpos >= endpos. So for example, it's possible when the output exactly matches the buffer space available that curpos == endpos will be true when apr_vformatter returns.
apr_vformatter does not call out to any other code, it is entirely self-contained. This allows the callers to do things which are otherwise "unsafe". For example, apr_psprintf uses the "scratch" space at the unallocated end of a block, and doesn't actually complete the allocation until apr_vformatter returns. apr_psprintf would be completely broken if apr_vformatter were to call anything that used this same pool. Similarly http_bprintf() uses the "scratch" space at the end of its output buffer, and doesn't actually note that the space is in use until it either has to flush the buffer or until apr_vformatter returns.