#include "asterisk/inline_api.h"
Go to the source code of this file.
Data Structures | |
struct | ast_string_field_mgr |
struct | ast_string_field_pool |
Defines | |
#define | ast_calloc_with_stringfields(n, type, size) |
Allocate a structure with embedded stringfields in a single allocation. | |
#define | AST_DECLARE_STRING_FIELDS(field_list) |
Declare the fields needed in a structure. | |
#define | AST_STRING_FIELD(name) const ast_string_field name |
Declare a string field. | |
#define | AST_STRING_FIELD_ALLOCATION(x) *((ast_string_field_allocation *) (x - sizeof(ast_string_field_allocation))) |
Macro to provide access to the allocation field that lives immediately in front of a string field. | |
#define | ast_string_field_build(x, field, fmt, args...) __ast_string_field_ptr_build(&(x)->__field_mgr, &(x)->__field_mgr_pool, (ast_string_field *) &(x)->field, fmt, args) |
Set a field to a complex (built) value. | |
#define | ast_string_field_build_va(x, field, fmt, args1, args2) __ast_string_field_ptr_build_va(&(x)->__field_mgr, &(x)->__field_mgr_pool, (ast_string_field *) &(x)->field, fmt, args1, args2) |
Set a field to a complex (built) value. | |
#define | ast_string_field_free_memory(x) __ast_string_field_init(&(x)->__field_mgr, &(x)->__field_mgr_pool, -1, __FILE__, __LINE__, __PRETTY_FUNCTION__) |
free all memory - to be called before destroying the object | |
#define | ast_string_field_init(x, size) __ast_string_field_init(&(x)->__field_mgr, &(x)->__field_mgr_pool, size, __FILE__, __LINE__, __PRETTY_FUNCTION__) |
Initialize a field pool and fields. | |
#define | ast_string_field_ptr_build(x, ptr, fmt, args...) __ast_string_field_ptr_build(&(x)->__field_mgr, &(x)->__field_mgr_pool, (ast_string_field *) ptr, fmt, args) |
Set a field to a complex (built) value. | |
#define | ast_string_field_ptr_build_va(x, ptr, fmt, args1, args2) __ast_string_field_ptr_build_va(&(x)->__field_mgr, &(x)->__field_mgr_pool, (ast_string_field *) ptr, fmt, args1, args2) |
Set a field to a complex (built) value with prebuilt va_lists. | |
#define | ast_string_field_ptr_set(x, ptr, data) |
Set a field to a simple string value. | |
#define | ast_string_field_set(x, field, data) |
Set a field to a simple string value. | |
Typedefs | |
typedef const char * | ast_string_field |
typedef uint16_t | ast_string_field_allocation |
Functions | |
void *attribute_malloc | __ast_calloc_with_stringfields (unsigned int num_structs, size_t struct_size, size_t field_mgr_offset, size_t field_mgr_pool_offset, size_t pool_size, const char *file, int lineno, const char *func) |
ast_string_field | __ast_string_field_alloc_space (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, size_t needed) |
int | __ast_string_field_init (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, int needed, const char *file, int lineno, const char *func) |
void | __ast_string_field_ptr_build (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, ast_string_field *ptr, const char *format,...) |
void | __ast_string_field_ptr_build_va (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, ast_string_field *ptr, const char *format, va_list a1, va_list a2) |
int | __ast_string_field_ptr_grow (struct ast_string_field_mgr *mgr, struct ast_string_field_pool **pool_head, size_t needed, const ast_string_field *ptr) |
void | __ast_string_field_release_active (struct ast_string_field_pool *pool_head, const ast_string_field ptr) |
Variables | |
const char * | __ast_string_field_empty |
This file contains objects and macros used to manage string fields in structures without requiring them to be allocated as fixed-size buffers or requiring individual allocations for for each field.
Using this functionality is quite simple. An example structure with three fields is defined like this:
struct sample_fields { int x1; AST_DECLARE_STRING_FIELDS( AST_STRING_FIELD(foo); AST_STRING_FIELD(bar); AST_STRING_FIELD(blah); ); long x2; };
When an instance of this structure is allocated (either statically or dynamically), the fields and the pool of storage for them must be initialized:
struct sample_fields *x; x = ast_calloc(1, sizeof(*x)); if (x == NULL || ast_string_field_init(x, 252)) { if (x) ast_free(x); x = NULL; ... handle error }
Fields will default to pointing to an empty string, and will revert to that when ast_string_field_set() is called with a NULL argument. A string field will never contain NULL.
ast_string_field_init(x, 0) will reset fields to the initial value while keeping the pool allocated.
Reading the fields is much like using 'const char * const' fields in the structure: you cannot write to the field or to the memory it points to.
Writing to the fields must be done using the wrapper macros listed below; and assignments are always by value (i.e. strings are copied): ast_string_field_set() stores a simple value; ast_string_field_build() builds the string using a printf-style format; ast_string_field_build_va() is the varargs version of the above (for portability reasons it uses two vararg arguments); variants of these function allow passing a pointer to the field as an argument.
ast_string_field_set(x, foo, "infinite loop"); ast_string_field_set(x, foo, NULL); // set to an empty string ast_string_field_ptr_set(x, &x->bar, "right way"); ast_string_field_build(x, blah, "%d %s", zipcode, city); ast_string_field_ptr_build(x, &x->blah, "%d %s", zipcode, city); ast_string_field_build_va(x, bar, fmt, args1, args2) ast_string_field_ptr_build_va(x, &x->bar, fmt, args1, args2)
When the structure instance is no longer needed, the fields and their storage pool must be freed:
ast_string_field_free_memory(x); ast_free(x);
This completes the API description.
Definition in file stringfields.h.
#define ast_calloc_with_stringfields | ( | n, | |||
type, | |||||
size | ) |
Value:
__ast_calloc_with_stringfields(n, sizeof(type), offsetof(type, __field_mgr), offsetof(type, __field_mgr_pool), \ size, __FILE__, __LINE__, __PRETTY_FUNCTION__)
n | Number of structures to allocate (see ast_calloc) | |
type | The type of structure to allocate | |
size | The number of bytes of space (minimum) to allocate for stringfields to use |
Definition at line 269 of file stringfields.h.
Referenced by append_mailbox_mapping(), ast_log(), ast_manager_register2(), build_extension(), jack_data_alloc(), load_config(), load_module(), pbx_builtin_raise_exception(), register_group(), register_group_feature(), sip_register(), sip_subscribe_mwi(), sla_build_station(), and sla_build_trunk().
#define AST_DECLARE_STRING_FIELDS | ( | field_list | ) |
Value:
struct ast_string_field_pool *__field_mgr_pool; \ field_list \ struct ast_string_field_mgr __field_mgr
field_list | The list of fields to declare, using AST_STRING_FIELD() for each one. Internally, string fields are stored as a pointer to the head of the pool, followed by individual string fields, and then a struct ast_string_field_mgr which describes the space allocated. We split the two variables so they can be used as markers around the field_list, and this allows us to determine how many entries are in the field, and play with them. In particular, for writing to the fields, we rely on __field_mgr_pool to be a non-const pointer, so we know it has the same size as ast_string_field, and we can use it to locate the fields. |
Definition at line 229 of file stringfields.h.
#define AST_STRING_FIELD | ( | name | ) | const ast_string_field name |
Declare a string field.
name | The field name |
Definition at line 214 of file stringfields.h.
#define AST_STRING_FIELD_ALLOCATION | ( | x | ) | *((ast_string_field_allocation *) (x - sizeof(ast_string_field_allocation))) |
Macro to provide access to the allocation field that lives immediately in front of a string field.
x | Pointer to the string field |
Definition at line 304 of file stringfields.h.
Referenced by __ast_string_field_alloc_space(), __ast_string_field_ptr_build_va(), __ast_string_field_ptr_grow(), and __ast_string_field_release_active().
#define ast_string_field_build | ( | x, | |||
field, | |||||
fmt, | |||||
args... | ) | __ast_string_field_ptr_build(&(x)->__field_mgr, &(x)->__field_mgr_pool, (ast_string_field *) &(x)->field, fmt, args) |
Set a field to a complex (built) value.
x | Pointer to a structure containing fields | |
field | Name of the field to set | |
fmt | printf-style format string | |
args | Arguments for format string |
Definition at line 360 of file stringfields.h.
Referenced by __ast_channel_alloc_ap(), build_callid_pvt(), build_callid_registry(), build_contact(), build_user(), caldav_write_event(), create_addr_from_peer(), handle_request_subscribe(), init_acf_query(), load_config(), parse_cdata(), parse_moved_contact(), parse_register_contact(), set_nonce_randdata(), sip_sendhtml(), sip_sipredirect(), and t30_phase_e_handler().
#define ast_string_field_build_va | ( | x, | |||
field, | |||||
fmt, | |||||
args1, | |||||
args2 | ) | __ast_string_field_ptr_build_va(&(x)->__field_mgr, &(x)->__field_mgr_pool, (ast_string_field *) &(x)->field, fmt, args1, args2) |
Set a field to a complex (built) value.
x | Pointer to a structure containing fields | |
field | Name of the field to set | |
fmt | printf-style format string | |
args1 | argument one | |
args2 | argument two |
Definition at line 384 of file stringfields.h.
Referenced by __ast_channel_alloc_ap().
#define ast_string_field_free_memory | ( | x | ) | __ast_string_field_init(&(x)->__field_mgr, &(x)->__field_mgr_pool, -1, __FILE__, __LINE__, __PRETTY_FUNCTION__) |
free all memory - to be called before destroying the object
Definition at line 247 of file stringfields.h.
Referenced by __sip_destroy(), ast_channel_destructor(), ast_custom_function_unregister(), ast_dummy_channel_destructor(), ast_manager_unregister(), ast_unregister_application(), ast_unregister_groups(), build_user(), caldav_destructor(), calendar_destructor(), calendar_event_destructor(), delete_extension(), delete_file(), destroy_jack_data(), destroy_mailbox_mapping(), destroy_queue(), destroy_session_details(), destroy_station(), destroy_trunk(), ewscal_destructor(), exception_store_free(), exchangecal_destructor(), free_acf_query(), free_outgoing(), icalendar_destructor(), init_acf_query(), load_module(), peer_destructor(), profile_destructor(), pvt_destructor(), realtime_multi_odbc(), realtime_odbc(), route_destructor(), sip_destroy_peer(), sip_monitor_instance_destructor(), sip_registry_destroy(), sip_subscribe_mwi_destroy(), tds_unload_module(), temp_pvt_cleanup(), update_odbc(), and user_destructor().
#define ast_string_field_init | ( | x, | |||
size | ) | __ast_string_field_init(&(x)->__field_mgr, &(x)->__field_mgr_pool, size, __FILE__, __LINE__, __PRETTY_FUNCTION__) |
Initialize a field pool and fields.
x | Pointer to a structure containing fields | |
size | Amount of storage to allocate. Use 0 to reset fields to the default value, and release all but the most recent pool. size<0 (used internally) means free all pools. |
Definition at line 243 of file stringfields.h.
Referenced by __ast_channel_alloc_ap(), acf_retrieve_docs(), alloc_queue(), ast_calendar_event_alloc(), ast_dummy_channel_alloc(), ast_register_application2(), build_calendar(), build_peer(), build_profile(), build_route(), build_user(), caldav_load_calendar(), ewscal_load_calendar(), exchangecal_load_calendar(), ical_load_calendar(), init_acf_query(), init_outgoing(), init_pvt(), new_iax(), realtime_multi_odbc(), realtime_odbc(), session_details_new(), sip_alloc(), sip_monitor_instance_init(), tds_load_module(), temp_peer(), temp_pvt_init(), transmit_response_using_temp(), and update_odbc().
#define ast_string_field_ptr_build | ( | x, | |||
ptr, | |||||
fmt, | |||||
args... | ) | __ast_string_field_ptr_build(&(x)->__field_mgr, &(x)->__field_mgr_pool, (ast_string_field *) ptr, fmt, args) |
Set a field to a complex (built) value.
x | Pointer to a structure containing fields | |
ptr | Pointer to a field within the structure | |
fmt | printf-style format string | |
args | Arguments for format string |
Definition at line 349 of file stringfields.h.
#define ast_string_field_ptr_build_va | ( | x, | |||
ptr, | |||||
fmt, | |||||
args1, | |||||
args2 | ) | __ast_string_field_ptr_build_va(&(x)->__field_mgr, &(x)->__field_mgr_pool, (ast_string_field *) ptr, fmt, args1, args2) |
Set a field to a complex (built) value with prebuilt va_lists.
x | Pointer to a structure containing fields | |
ptr | Pointer to a field within the structure | |
fmt | printf-style format string | |
args1 | Arguments for format string in va_list format | |
args2 | a second copy of the va_list for the sake of bsd, with no va_list copy operation |
Definition at line 372 of file stringfields.h.
#define ast_string_field_ptr_set | ( | x, | |||
ptr, | |||||
data | ) |
Set a field to a simple string value.
x | Pointer to a structure containing fields | |
ptr | Pointer to a field within the structure | |
data | String value to be copied into the field |
Definition at line 313 of file stringfields.h.
Referenced by reply_digest().
#define ast_string_field_set | ( | x, | |||
field, | |||||
data | ) |
Value:
do { \ ast_string_field_ptr_set(x, &(x)->field, data); \ } while (0)
x | Pointer to a structure containing fields | |
field | Name of the field to set | |
data | String value to be copied into the field |
Definition at line 337 of file stringfields.h.
Referenced by __ast_change_name_nolink(), __ast_channel_alloc_ap(), __find_callno(), __oh323_new(), __sip_subscribe_mwi_do(), acf_faxopt_write(), acf_retrieve_docs(), agent_new(), alloc_queue(), alsa_new(), analog_new_ast_channel(), append_mailbox_mapping(), apply_outgoing(), ast_call_forward(), ast_cdr_setaccount(), ast_cdr_setpeeraccount(), ast_cel_fabricate_channel_from_event(), ast_channel_change_linkedid(), ast_do_masquerade(), ast_iax2_new(), ast_log(), ast_manager_register2(), ast_parse_digest(), ast_register_application2(), ast_set_hangupsource(), ast_set_owners_and_peers(), authenticate_reply(), authenticate_request(), authenticate_verify(), begin_dial_channel(), build_calendar(), build_extension(), build_peer(), build_profile(), build_route(), build_user(), cache_get_callno_locked(), caldav_add_event(), caldav_load_calendar(), calendar_write_exec(), check_access(), check_peer_ok(), check_user_full(), conf_start_moh(), console_new(), copy_event_data(), create_addr(), create_addr_from_peer(), custom_prepare(), dahdi_new(), dial_exec_full(), do_forward(), endelm(), ewscal_load_calendar(), exchangecal_load_calendar(), extract_uri(), feature_request_and_dial(), findmeexec(), generic_fax_exec(), get_also_info(), get_destination(), get_pai(), get_realm(), get_rpid(), gtalk_new(), handle_cc_notify(), handle_incoming(), handle_options(), handle_request_bye(), handle_request_invite(), handle_request_options(), handle_request_publish(), handle_request_refer(), handle_response(), handle_response_invite(), handle_response_notify(), handle_response_publish(), handle_response_subscribe(), iax2_call(), iax2_request(), ical_load_calendar(), icalendar_add_event(), init_acf_query(), init_pvt(), init_queue(), initreqprep(), jingle_new(), load_config(), local_call(), logger_print_normal(), mgcp_new(), misdn_facility_ie_handler(), moh_handle_digit(), monitor_dial(), nbs_new(), new_iax(), oss_new(), parse_moved_contact(), parse_ok_contact(), parse_register_contact(), pbx_builtin_raise_exception(), phone_new(), queue_set_param(), read_config(), receivefax_exec(), reg_source_db(), register_group(), register_group_feature(), register_verify(), registry_authrequest(), reply_digest(), reqprep(), respprep(), ring_entry(), save_osptoken(), sendfax_exec(), set_moh_exec(), set_peer_defaults(), set_pvt_defaults(), sig_pri_handle_subcmds(), sip_alloc(), sip_call(), sip_monitor_instance_init(), sip_new(), sip_park(), sip_poke_peer(), sip_request_call(), sip_send_mwi_to_peer(), sip_set_redirstr(), sip_subscribe_mwi(), skinny_new(), sla_build_station(), sla_build_trunk(), socket_process(), startelm(), store_callerid(), t30_phase_e_handler(), tds_load_module(), transmit_refer(), transmit_register(), transmit_response_using_temp(), unistim_new(), usbradio_new(), vm_execmain(), and wait_for_answer().
typedef const char* ast_string_field |
Definition at line 115 of file stringfields.h.
typedef uint16_t ast_string_field_allocation |
Definition at line 298 of file stringfields.h.
void* attribute_malloc __ast_calloc_with_stringfields | ( | unsigned int | num_structs, | |
size_t | struct_size, | |||
size_t | field_mgr_offset, | |||
size_t | field_mgr_pool_offset, | |||
size_t | pool_size, | |||
const char * | file, | |||
int | lineno, | |||
const char * | func | |||
) |
Definition at line 1775 of file utils.c.
References __ast_calloc(), __ast_string_field_empty, allocation, ast_calloc, ast_string_field_pool::base, ast_string_field_mgr::embedded_pool, optimal_alloc_size(), and ast_string_field_pool::size.
01778 { 01779 struct ast_string_field_mgr *mgr; 01780 struct ast_string_field_pool *pool; 01781 struct ast_string_field_pool **pool_head; 01782 size_t pool_size_needed = sizeof(*pool) + pool_size; 01783 size_t size_to_alloc = optimal_alloc_size(struct_size + pool_size_needed); 01784 void *allocation; 01785 unsigned int x; 01786 01787 #if defined(__AST_DEBUG_MALLOC) 01788 if (!(allocation = __ast_calloc(num_structs, size_to_alloc, file, lineno, func))) { 01789 return NULL; 01790 } 01791 #else 01792 if (!(allocation = ast_calloc(num_structs, size_to_alloc))) { 01793 return NULL; 01794 } 01795 #endif 01796 01797 for (x = 0; x < num_structs; x++) { 01798 void *base = allocation + (size_to_alloc * x); 01799 const char **p; 01800 01801 mgr = base + field_mgr_offset; 01802 pool_head = base + field_mgr_pool_offset; 01803 pool = base + struct_size; 01804 01805 p = (const char **) pool_head + 1; 01806 while ((struct ast_string_field_mgr *) p != mgr) { 01807 *p++ = __ast_string_field_empty; 01808 } 01809 01810 mgr->embedded_pool = pool; 01811 *pool_head = pool; 01812 pool->size = size_to_alloc - struct_size - sizeof(*pool); 01813 #if defined(__AST_DEBUG_MALLOC) 01814 mgr->owner_file = file; 01815 mgr->owner_func = func; 01816 mgr->owner_line = lineno; 01817 #endif 01818 } 01819 01820 return allocation; 01821 }
ast_string_field __ast_string_field_alloc_space | ( | struct ast_string_field_mgr * | mgr, | |
struct ast_string_field_pool ** | pool_head, | |||
size_t | needed | |||
) |
Definition at line 1611 of file utils.c.
References add_string_pool(), AST_STRING_FIELD_ALLOCATION, and ast_string_field_mgr::last_alloc.
Referenced by __ast_string_field_ptr_build_va().
01613 { 01614 char *result = NULL; 01615 size_t space = (*pool_head)->size - (*pool_head)->used; 01616 size_t to_alloc = needed + sizeof(ast_string_field_allocation); 01617 01618 /* This +1 accounts for alignment on SPARC */ 01619 if (__builtin_expect(to_alloc + 1 > space, 0)) { 01620 size_t new_size = (*pool_head)->size; 01621 01622 while (new_size < to_alloc) { 01623 new_size *= 2; 01624 } 01625 01626 #if defined(__AST_DEBUG_MALLOC) 01627 if (add_string_pool(mgr, pool_head, new_size, mgr->owner_file, mgr->owner_line, mgr->owner_func)) 01628 return NULL; 01629 #else 01630 if (add_string_pool(mgr, pool_head, new_size, __FILE__, __LINE__, __FUNCTION__)) 01631 return NULL; 01632 #endif 01633 } 01634 01635 result = (*pool_head)->base + (*pool_head)->used; 01636 #ifdef __sparc__ 01637 /* SPARC requires that the allocation field be aligned. */ 01638 if ((long) result % sizeof(ast_string_field_allocation)) { 01639 result++; 01640 (*pool_head)->used++; 01641 } 01642 #endif 01643 (*pool_head)->used += to_alloc; 01644 (*pool_head)->active += needed; 01645 result += sizeof(ast_string_field_allocation); 01646 AST_STRING_FIELD_ALLOCATION(result) = needed; 01647 mgr->last_alloc = result; 01648 01649 return result; 01650 }
int __ast_string_field_init | ( | struct ast_string_field_mgr * | mgr, | |
struct ast_string_field_pool ** | pool_head, | |||
int | needed, | |||
const char * | file, | |||
int | lineno, | |||
const char * | func | |||
) |
Definition at line 1544 of file utils.c.
References ast_string_field_pool::active, add_string_pool(), ast_free, ast_log(), ast_string_field_mgr::embedded_pool, ast_string_field_mgr::last_alloc, LOG_WARNING, ast_string_field_pool::prev, and ast_string_field_pool::used.
01546 { 01547 const char **p = (const char **) pool_head + 1; 01548 struct ast_string_field_pool *cur = NULL; 01549 struct ast_string_field_pool *preserve = NULL; 01550 01551 /* clear fields - this is always necessary */ 01552 while ((struct ast_string_field_mgr *) p != mgr) { 01553 *p++ = __ast_string_field_empty; 01554 } 01555 01556 mgr->last_alloc = NULL; 01557 #if defined(__AST_DEBUG_MALLOC) 01558 mgr->owner_file = file; 01559 mgr->owner_func = func; 01560 mgr->owner_line = lineno; 01561 #endif 01562 if (needed > 0) { /* allocate the initial pool */ 01563 *pool_head = NULL; 01564 mgr->embedded_pool = NULL; 01565 return add_string_pool(mgr, pool_head, needed, file, lineno, func); 01566 } 01567 01568 /* if there is an embedded pool, we can't actually release *all* 01569 * pools, we must keep the embedded one. if the caller is about 01570 * to free the structure that contains the stringfield manager 01571 * and embedded pool anyway, it will be freed as part of that 01572 * operation. 01573 */ 01574 if ((needed < 0) && mgr->embedded_pool) { 01575 needed = 0; 01576 } 01577 01578 if (needed < 0) { /* reset all pools */ 01579 cur = *pool_head; 01580 } else if (mgr->embedded_pool) { /* preserve the embedded pool */ 01581 preserve = mgr->embedded_pool; 01582 cur = *pool_head; 01583 } else { /* preserve the last pool */ 01584 if (*pool_head == NULL) { 01585 ast_log(LOG_WARNING, "trying to reset empty pool\n"); 01586 return -1; 01587 } 01588 preserve = *pool_head; 01589 cur = preserve->prev; 01590 } 01591 01592 if (preserve) { 01593 preserve->prev = NULL; 01594 preserve->used = preserve->active = 0; 01595 } 01596 01597 while (cur) { 01598 struct ast_string_field_pool *prev = cur->prev; 01599 01600 if (cur != preserve) { 01601 ast_free(cur); 01602 } 01603 cur = prev; 01604 } 01605 01606 *pool_head = preserve; 01607 01608 return 0; 01609 }
void __ast_string_field_ptr_build | ( | struct ast_string_field_mgr * | mgr, | |
struct ast_string_field_pool ** | pool_head, | |||
ast_string_field * | ptr, | |||
const char * | format, | |||
... | ||||
) |
Definition at line 1760 of file utils.c.
References __ast_string_field_ptr_build_va().
01763 { 01764 va_list ap1, ap2; 01765 01766 va_start(ap1, format); 01767 va_start(ap2, format); /* va_copy does not exist on FreeBSD */ 01768 01769 __ast_string_field_ptr_build_va(mgr, pool_head, ptr, format, ap1, ap2); 01770 01771 va_end(ap1); 01772 va_end(ap2); 01773 }
void __ast_string_field_ptr_build_va | ( | struct ast_string_field_mgr * | mgr, | |
struct ast_string_field_pool ** | pool_head, | |||
ast_string_field * | ptr, | |||
const char * | format, | |||
va_list | a1, | |||
va_list | a2 | |||
) |
Definition at line 1695 of file utils.c.
References __ast_string_field_alloc_space(), __ast_string_field_empty, __ast_string_field_release_active(), AST_STRING_FIELD_ALLOCATION, available(), and ast_string_field_mgr::last_alloc.
Referenced by __ast_string_field_ptr_build().
01698 { 01699 size_t needed; 01700 size_t available; 01701 size_t space = (*pool_head)->size - (*pool_head)->used; 01702 ssize_t grow; 01703 char *target; 01704 01705 /* if the field already has space allocated, try to reuse it; 01706 otherwise, try to use the empty space at the end of the current 01707 pool 01708 */ 01709 if (*ptr != __ast_string_field_empty) { 01710 target = (char *) *ptr; 01711 available = AST_STRING_FIELD_ALLOCATION(*ptr); 01712 if (*ptr == mgr->last_alloc) { 01713 available += space; 01714 } 01715 } else { 01716 target = (*pool_head)->base + (*pool_head)->used + sizeof(ast_string_field_allocation); 01717 #ifdef __sparc__ 01718 if ((long) target % sizeof(ast_string_field_allocation)) { 01719 target++; 01720 space--; 01721 } 01722 #endif 01723 available = space - sizeof(ast_string_field_allocation); 01724 } 01725 01726 needed = vsnprintf(target, available, format, ap1) + 1; 01727 01728 va_end(ap1); 01729 01730 if (needed > available) { 01731 /* the allocation could not be satisfied using the field's current allocation 01732 (if it has one), or the space available in the pool (if it does not). allocate 01733 space for it, adding a new string pool if necessary. 01734 */ 01735 if (!(target = (char *) __ast_string_field_alloc_space(mgr, pool_head, needed))) { 01736 return; 01737 } 01738 vsprintf(target, format, ap2); 01739 __ast_string_field_release_active(*pool_head, *ptr); 01740 *ptr = target; 01741 } else if (*ptr != target) { 01742 /* the allocation was satisfied using available space in the pool, but not 01743 using the space already allocated to the field 01744 */ 01745 __ast_string_field_release_active(*pool_head, *ptr); 01746 mgr->last_alloc = *ptr = target; 01747 AST_STRING_FIELD_ALLOCATION(target) = needed; 01748 (*pool_head)->used += needed + sizeof(ast_string_field_allocation); 01749 (*pool_head)->active += needed; 01750 } else if ((grow = (needed - AST_STRING_FIELD_ALLOCATION(*ptr))) > 0) { 01751 /* the allocation was satisfied by using available space in the pool *and* 01752 the field was the last allocated field from the pool, so it grew 01753 */ 01754 (*pool_head)->used += grow; 01755 (*pool_head)->active += grow; 01756 AST_STRING_FIELD_ALLOCATION(*ptr) += grow; 01757 } 01758 }
int __ast_string_field_ptr_grow | ( | struct ast_string_field_mgr * | mgr, | |
struct ast_string_field_pool ** | pool_head, | |||
size_t | needed, | |||
const ast_string_field * | ptr | |||
) |
Definition at line 1652 of file utils.c.
References AST_STRING_FIELD_ALLOCATION, and ast_string_field_mgr::last_alloc.
01655 { 01656 ssize_t grow = needed - AST_STRING_FIELD_ALLOCATION(*ptr); 01657 size_t space = (*pool_head)->size - (*pool_head)->used; 01658 01659 if (*ptr != mgr->last_alloc) { 01660 return 1; 01661 } 01662 01663 if (space < grow) { 01664 return 1; 01665 } 01666 01667 (*pool_head)->used += grow; 01668 (*pool_head)->active += grow; 01669 AST_STRING_FIELD_ALLOCATION(*ptr) += grow; 01670 01671 return 0; 01672 }
void __ast_string_field_release_active | ( | struct ast_string_field_pool * | pool_head, | |
const ast_string_field | ptr | |||
) |
Definition at line 1674 of file utils.c.
References ast_string_field_pool::active, ast_free, AST_STRING_FIELD_ALLOCATION, and ast_string_field_pool::prev.
Referenced by __ast_string_field_ptr_build_va().
01676 { 01677 struct ast_string_field_pool *pool, *prev; 01678 01679 if (ptr == __ast_string_field_empty) { 01680 return; 01681 } 01682 01683 for (pool = pool_head, prev = NULL; pool; prev = pool, pool = pool->prev) { 01684 if ((ptr >= pool->base) && (ptr <= (pool->base + pool->size))) { 01685 pool->active -= AST_STRING_FIELD_ALLOCATION(ptr); 01686 if ((pool->active == 0) && prev) { 01687 prev->prev = pool->prev; 01688 ast_free(pool); 01689 } 01690 break; 01691 } 01692 } 01693 }
const char* __ast_string_field_empty |
Definition at line 1489 of file utils.c.
Referenced by __ast_calloc_with_stringfields(), and __ast_string_field_ptr_build_va().