Wed Apr 6 11:30:11 2011

Asterisk developer's documentation


stringfields.h File Reference

String fields in structures. More...

#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


Detailed Description

String fields in structures.

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 Documentation

#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__)
Allocate a structure with embedded stringfields in a single allocation.

Parameters:
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
This function will allocate memory for one or more structures that use stringfields, and also allocate space for the stringfields and initialize the stringfield management structure embedded in the outer structure.

Since:
1.8

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
Declare the fields needed in a structure.

Parameters:
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.

Parameters:
name The field name

Definition at line 214 of file stringfields.h.

#define AST_STRING_FIELD_ALLOCATION (  )     *((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.

Parameters:
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.

Parameters:
x Pointer to a structure containing fields
field Name of the field to set
fmt printf-style format string
args Arguments for format string
Returns:
nothing

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.

Parameters:
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
Returns:
nothing

Definition at line 384 of file stringfields.h.

Referenced by __ast_channel_alloc_ap().

#define ast_string_field_free_memory (  )     __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.

Parameters:
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.
Returns:
0 on success, non-zero on failure

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.

Parameters:
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
Returns:
nothing

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.

Parameters:
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
Returns:
nothing

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.

Parameters:
x Pointer to a structure containing fields
ptr Pointer to a field within the structure
data String value to be copied into the field
Returns:
nothing

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)
Set a field to a simple string value.

Parameters:
x Pointer to a structure containing fields
field Name of the field to set
data String value to be copied into the field
Returns:
nothing

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 Documentation

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.


Function Documentation

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 }


Variable Documentation

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().


Generated on Wed Apr 6 11:30:11 2011 for Asterisk - The Open Source Telephony Project by  doxygen 1.4.7