#define __CSURF_MARKER_LIBRARY_FUNCTION__ 1  

it *csonar_replace_my_iterator_New( void )
{...}

#undef __CSURF_MARKER_LIBRARY_FUNCTION__

CSONAR_DEFINE_ATTRIBUTE(open);

CSONAR_DECLARE_ATTRIBUTE(open);

#define __CSURF_MARKER_LIBRARY_FUNCTION__ 1
                          
int csonar_replace_add(int x, int y){
    /* update necessary attributes */
    /* ... */
    return add(x,y)
}

#undef __CSURF_MARKER_LIBRARY_FUNCTION__

FILE *f;
...
if (csonar_get_open(f)){
    ... 

FILE *f;
...
csonar_set_open( f, 0 );

csonar_name_open( 0, "closed");
csonar_name_open( 1, "open");

FILE *f;
...
csonar_trigger( 
    csonar_get_open( f ), 
    "==", 
    0, 
    "Double Close" );

FILE *f;
/* ... */
csonar_trigger_m( 
    csonar_get_open( f ), 
    "==", 
    0, 
    "Double Close",
    "IO.DC;CWE:672;CWE:675",
    csws_reliability );

double myfunc (double x){
        csonar_trigger_f( x, 
                          "<", 
                                          0.0, 
                                          "Negative myfunc argument", 
                                          "", 
                                          csws_reliability );
    /* ... */
}

csonar_important_global(&foo);

csonar_trigger_m(
    (int)p, 
    "<", 
    (int)csonar_nullness_threshold(),
    "Free Null Pointer",
    "ALLOC.FNP;CWE:590",
    csws_redundancy);

int *p = malloc( 4 );
csonar_escape(p);
i = *p;   /* Uninitialized Variable NOT reported: 
           *  *p might have been initialized */

#define __CSURF_MARKER_LIBRARY_FUNCTION__ 1

char *strcadd(char *output, const char *inputstr)
{
    int pos;
        
    /* Invoke the strlen() model to carry out basic string checking on inputstr. */    
    strlen(inputstr); 
        
    /* For the taint analysis, model the output contents as unknown and 
     * tainted by inputstr. For the remainder of the analysis, model the 
     * output contents as untrusted. */
    output[0] = csonar_taint_mux(csonar_string_taint(inputstr),
                                 cs_untrusted_value());

    /* For the taint analysis, model the length of the copied portion of
     * inputstr as unknown amd tainted by inputstr; for the remainder of the analysis
     * model the copied length as an untrusted value. In both cases, specify that the 
     * copied length is bounded below by 0 and above by the length of inputstr. */
    pos = csonar_bounded_value(csonar_taint_mux(csonar_string_taint(inputstr), 
                                                cs_untrusted_value()),
                               0, 
                               strlen(inputstr));
    output[pos] = '\0';
    return &output[pos];
}

#undef __CSURF_MARKER_LIBRARY_FUNCTION__

#define __CSURF_MARKER_LIBRARY_FUNCTION__ 1

int mkstemp(char *template)
{
    size_t len = strlen(template);             /* The strlen() model will also carry out 
                                                * basic string checking on template. */  
    if( len == 0 )                    
        return -1;                             /* Model the mkstemp() failure case. */
    template[cs_untrusted_value_bound(0, len-1)] = 'c';
    return open( template, 0 );                /* mkstemp() returns an open file descriptor
                                                * on success: invoke the existing open() model
                                                * to take advantage of the checking and 
                                                * relationship expression it provides. */
}

#undef __CSURF_MARKER_LIBRARY_FUNCTION__

#define __CSURF_MARKER_LIBRARY_FUNCTION__ 1

int _umask_s(int pmode, int * pOldMode)
{
    *pOldMode = umask(pmode);               /* Invoke the existing umask() model. */
    return cs_untrusted_untainted_value();  /* Return value is untrusted but untainted. */
}

#undef __CSURF_MARKER_LIBRARY_FUNCTION__

#define __CSURF_MARKER_LIBRARY_FUNCTION__ 1

/* Function that contains the checking code for class "Security Problem in myfunc".  */
int do_very_expensive_check(int * a, int b){
    if (/* [...] checking code */){
        return 1;
    if (/* [...] more checking code */){
        return 2;
    return 0;
}


/* CodeSonar will intercept calls to myfunc() and redirect them to csonar_replace_myfunc(). */
int csonar_replace_myfunc(int * intptr, int index)
{
    /* Use the value of csonar_warningclass_always_discarded_lm("Security Problem in myfunc") to 
     * guard the call to do_very_expensive_check(). */
    if (!csonar_warningclass_always_discarded_lm("Security Problem in myfunc")){
        csonar_trigger(do_very_expensive_check(intptr, index), "!=", 0, "Security Problem in myfunc")
        }

    /* Invoke the myfunc() function so its behavior can be analyzed. */
    return myfunc(int * intptr, int index);
}

#undef __CSURF_MARKER_LIBRARY_FUNCTION__

char * my_init_char(int n){
    csonar_dyn_init();
    return malloc(n);
}                         
                          
int main(int argc, char *argv[]){
    char *s = my_init_char(5); /* Dynamic Allocation After Initialization 
                                  NOT reported */
    ...
}

char * init_char(int n){
    return malloc(n);
}                         
                          
int mymain(void){
    csonar_entry_point();
    char *s = init_char(5); /* Dynamic Allocation After Initialization
                               reported */
    ...
}

#define __CSURF_MARKER_LIBRARY_FUNCTION__ 1

int mylock(mymutex_t *m){
    int retval = CSM_UNKNOWN_INTEGER(); /* Use CSM_UNKNOWN_INTEGER() to model failure 
                                         * as a random occurrence that cannot be 
                                         * detected statically. */

    csonar_mutex_pre_acquire(m);        /* Call csonar_mutex_pre_acquire() before
                                         * calling csonar_mutex_acquire() or
                                         * csonar_mutex_acquire_failed(). */        

    if( csonar_mutex_failure_behavior() == CSONAR_MXFB_DOESNT_FAIL || retval == 0 )
                                        /* The failure case should not occur if 
                                         * MUTEX_FAILURE_BEHAVIOR is set to DOESNT_FAIL -
                                         * use csonar_mutex_failure_behavior() to check. */
    {   
        csonar_mutex_acquire(m);        /* Call csonar_mutex_acquire() on success path. */      
        return 0;
    }
    else
    {   
        csonar_mutex_acquire_failed(m); /* Call csonar_mutex_acquire_failed() on failure 
                                         * path. */
        return retval;
    }
}

#undef __CSURF_MARKER_LIBRARY_FUNCTION__

#define __CSURF_MARKER_LIBRARY_FUNCTION__ 1

int mytrylock(mymutex_t *m){
    int retval = CSM_UNKNOWN_INTEGER(); /* Use CSM_UNKNOWN_INTEGER() to model failure 
                                         * as a random occurrence that cannot be 
                                         * detected statically. */

    csonar_mutex_pre_try_acquire(m);    /* Call csonar_mutex_pre_try_acquire() before
                                         * calling csonar_mutex_acquire(). */        

    if( retval == 0 )
    {   
        csonar_mutex_acquire(m);        /* Call csonar_mutex_acquire() on success path. */      
        return 0;
    }
    return retval;
}

#undef __CSURF_MARKER_LIBRARY_FUNCTION__

#define __CSURF_MARKER_LIBRARY_FUNCTION__ 1

int myunlock(mymutex_t *m){
    int retval = CSM_UNKNOWN_INTEGER(); /* Use CSM_UNKNOWN_INTEGER() to model failure 
                                         * as a random occurrence that cannot be 
                                         * detected statically. */

    csonar_mutex_pre_release(m);        /* Call csonar_mutex_pre_release() on 
                                         * all branches, and before any call to 
                                         * csonar_mutex_release(). 
                                         * If m is reentrant or recursive, call
                                         * csonar_mutex_pre_release_reent() instead. */              

    if( csonar_mutex_failure_behavior() == CSONAR_MXFB_DOESNT_FAIL || retval == 0 )
                                        /* The failure case should not occur if 
                                         * MUTEX_FAILURE_BEHAVIOR is set to DOESNT_FAIL -
                                         * use csonar_mutex_failure_behavior() to check. */
    {   
        csonar_mutex_release(m);        /* Call csonar_mutex_release() on success path. */      
        return 0;
    }
    return retval;
}

#undef __CSURF_MARKER_LIBRARY_FUNCTION__

#define __CSURF_MARKER_LIBRARY_FUNCTION__ 1

my_thread_t *my_signal_handler(void * (*f)(void *)){
    int retval = CSM_UNKNOWN_INTEGER(); /* Use CSM_UNKNOWN_INTEGER() to model failure 
                                         * as a random occurrence that cannot be 
                                         * detected statically. */
    if (retval){
            csonar_sighand_create(f, NULL);   /* Call csonar_sighand_create() on success path. */
        }
    return (my_thread_t *)retval;
}

#undef __CSURF_MARKER_LIBRARY_FUNCTION__
        

#define __CSURF_MARKER_LIBRARY_FUNCTION__ 1

my_thread_t *my_thread_create(void * (*f)(void *)){
    int retval = CSM_UNKNOWN_INTEGER(); /* Use CSM_UNKNOWN_INTEGER() to model failure 
                                         * as a random occurrence that cannot be 
                                         * detected statically. */
    if (retval){
            csonar_thread_create(f, NULL);   /* Call csonar_thread_create() on success path. */
        }
    return (my_thread_t *)retval;
}

#undef __CSURF_MARKER_LIBRARY_FUNCTION__

#define __CSURF_MARKER_LIBRARY_FUNCTION__ 1

void my_big_io_function(void){
    csonar_blocking_function(); /* Call csonar_blocking_function() to indicate that  
                                 * my_big_io_function() is a blocking function and  
                                 * should not be called inside a critical section.*/    
    read_big_input();
    write_big_output();                    
    return;
}

#undef __CSURF_MARKER_LIBRARY_FUNCTION__

CSONAR_DEFINE_TAINT_SOURCE(telephone);

#define __CSURF_MARKER_LIBRARY_FUNCTION__ 1

char *_cgets(char *buffer)
{
    int len;
                                    /* _cgets() reads a string from the console, so model the space 
                                     * required to accommodate the read string plus additional information as
                                     * having taint kind file. Upper and lower bounds on this value 
                                     * are entailed by the _cgets() specification. */
    len = csonar_bounded_value(csonar_taint_source_file(), 
                               2, 
                               buffer[0] + 2 );

                                    /* The string contents also have taint kind file. */
    buffer[2] = csonar_taint_source_file(); 

    buffer[len] = '\0';             /* The tainted len value determines the position of the null terminator... */     
    buffer[1] = len;                /* ...and is also written to buffer[1]. */ 
    return &buffer[2];                      
}

#undef __CSURF_MARKER_LIBRARY_FUNCTION__

if( CSM_UNKNOWN_INTEGER() )
    {
    csonar_assert_taint_enabled();
    /* model code to be analyzed during the taint analysis phase */
    }
    else
    {
    csonar_assert_taint_disabled();
    /* model code to be analyzed during the other analysis phases */
    }
}

#define __CSURF_MARKER_LIBRARY_FUNCTION__ 1

char * csonar_replace_MySQLDetaint(char *s){
    char *rv;
    rv = MySQLDetaint(s);             /* Call the MySQLDetaint() function so its 
                                       * behavior can be analyzed. */
    csonar_taint_clear_int(rv);       /* The "int" attribute of an address is an alias 
                                       * for the memory contents at that address, so 
                                       * this clears taint from rv. */
    return rv;
}

#undef __CSURF_MARKER_LIBRARY_FUNCTION__

#define __CSURF_MARKER_LIBRARY_FUNCTION__ 1

int wctomb(char *mbchar, wchar_t wchar){
    int len;
    if( !mbchar )                /* wctomb() returns zero on null wchar. */
        return 0;
    if( CSM_UNKNOWN_INTEGER() )  /* wctomb() returns -1 on error. */
    {
        CSM_SETS_ERRNO_TO_NONZERO();
        return -1;
    }
                                 /* The number of chars required to represent wchar is
                                  * known to be either 0 or 1; the model instructs the analysis
                                  * to regard this number as untrusted and - for the taint
                                  * analysis - having the same taint status as wchar. */
    len = csonar_bounded_value(csonar_taint_mux(csonar_taint_transfer(wchar),
                                                cs_untrusted_value()),
                               0, 
                               1 );

                                 /* The output written to mbchar is generated from wchar, 
                                  * so has the same taint status as wchar. */ 
    mbchar[0] = csonar_taint_transfer(wchar);
    mbchar[len] = csonar_taint_transfer(wchar);

    return len + 1;              /* Model success-case return value. */
}

#undef __CSURF_MARKER_LIBRARY_FUNCTION__

#define __CSURF_MARKER_LIBRARY_FUNCTION__ 1

int sethostid(long hostid)
{
    csonar_taint_sink( csonar_taint_source_any(),
                       hostid, 
                       "Tainted Configuration Setting", 
                       "CWE:15",
                       csws_security );
    if( CSM_UNKNOWN_INTEGER() )
    {
        CSM_SETS_ERRNO_TO_NONZERO();
        return -1;
    }
    gethostid_hostid = hostid;
    return 0;
}

#undef __CSURF_MARKER_LIBRARY_FUNCTION__

#define __CSURF_MARKER_LIBRARY_FUNCTION__ 1

int atoi(const char *s)
{
    int rv;
    rv = csonar_taint_mux(csonar_string_taint(s),  
                          cs_untrusted_value());
    strlen(s);
    CSM_SETS_ERRNO();
    return rv;
}

#undef __CSURF_MARKER_LIBRARY_FUNCTION__

#define __CSURF_MARKER_LIBRARY_FUNCTION__ 1

int swscanf_s(wchar_t *s, const wchar_t *fmt, ... )
{
    int ret;
    wcslen( s );
    wcslen( fmt );
    ret = csonar_taint_mux(
        csonar_taint_union2(csonar_wcstring_taint( fmt ), 
                            csonar_wcstring_taint( s )),
        cs_untrusted_value());
    if( ret < -1 ) for(;;);
    if( CSM_UNKNOWN_INTEGER() && ret == -1 )
        CSM_SETS_ERRNO_TO_NONZERO();

    return ret;    
}

#undef __CSURF_MARKER_LIBRARY_FUNCTION__