p_persistency.c File Reference

---

Detailed Description

P-CSCF persistency operations.

Author:

Dragos Vingarzan vingarzan -at- fokus dot fraunhofer dot de

Definition in file p_persistency.c.

#include "p_persistency.h"

Go to the source code of this file.

Functions
int	p_dump (bin_data *x, char *location, char *prepend_fname, data_type_t dt)
	Dumps P-CSCF data to files or DB.
int	bin_dump_to_db (bin_data *x, data_type_t dt)
	Dumps P-CSCF data to DB.
int	bin_dump_registrar_to_table (bin_data *x, int snapshot_version, int step_version)
	Dumps P-CSCF registrar to DB.
int	bin_dump_dialogs_to_table (bin_data *x, int snapshot_version, int step_version)
	Dumps P-CSCF dialogs to DB.
int	bin_dump_subs_to_table (bin_data *x, int snapshot_version, int step_version)
	Dumps P-CSCF subscriptions to DB.
int	bin_bulk_dump_to_table (data_type_t dt, int snapshot_version, int step_version, bin_data *x)
	Dumps P-CSCF data to the snapshot table.
int	bin_cache_dump_registrar_to_table (int snapshot_version, int step_version)
	Dumps P-CSCF registrar to the snapshot table.
int	bin_cache_dump_dialogs_to_table (int snapshot_version, int step_version)
	Dumps P-CSCF dialogs to the snapshot table.
int	bin_cache_dump_subs_to_table (int snapshot_version, int step_version)
	Dumps P-CSCF subscriptions to the snapshot table.
int	delete_older_snapshots (char *table, char *node_id, data_type_t dt, int current_snapshot)
	Drops older subscriptions/dialogs/registrar snapshots, keeping the 'bin_db_keep_count' most recent.
int	p_load (bin_data *x, char *location, char *prepend_fname, data_type_t dt)
	Loads P-CSCF data from files or DB.
int	bin_load_from_db (bin_data *x, data_type_t dt)
	Loads P-CSCF data from DB.
int	bin_load_registrar_from_table (bin_data *x)
	Loads P-CSCF registrar from DB.
int	bin_load_dialogs_from_table (bin_data *x)
	Loads P-CSCF dialogs from DB.
int	bin_load_subscriptions_from_table (bin_data *x)
	Loads P-CSCF subscriptions from DB.
int	bin_bulk_load_from_table (data_type_t dt, bin_data *x)
	Loads P-CSCF data from the snapshot table.
int	bin_cache_load_registrar_from_table ()
	Loads P-CSCF registrar from the snapshot table.
int	bin_cache_load_dialogs_from_table ()
	Loads P-CSCF dialogs from the snapshot table.
int	bin_cache_load_subscriptions_from_table ()
	Loads P-CSCF subscriptions from the snapshot table.
int	db_get_last_snapshot_version (char *table, char *node_id, data_type_t dt, int *version)
	Gets the version of the last snapshot dumped to db.
int	set_versions (data_type_t dt, int snapshot_version, int step_version)
	Sets the values of the global variables registrar/dialogs/subs_snapshot_version and registrar/dialogs/subs_step_version.
int	make_snapshot_dialogs ()
	Creates a snapshots of the dialogs data and then calls the dumping function.
int	load_snapshot_dialogs ()
	Loads the dialogs data from the last snapshot.
void	persistency_timer_dialogs (unsigned int ticks, void *param)
	Timer callback for persistency dumps.
int	make_snapshot_registrar ()
	Creates a snapshots of the registrar and then calls the dumping function.
int	load_snapshot_registrar ()
	Loads the registrar data from the last snapshot.
void	persistency_timer_registrar (unsigned int ticks, void *param)
	Timer callback for persistency dumps.
int	make_snapshot_subscriptions ()
	Creates a snapshots of the subscriptions and then calls the dumping function.
int	load_snapshot_subscriptions ()
	Loads the subscriptions data from the last snapshot.
void	persistency_timer_subscriptions (unsigned int ticks, void *param)
	Timer callback for persistency dumps.
Variables
persistency_mode_t	pcscf_persistency_mode
	the type of persistency
char *	pcscf_persistency_location
	where to dump the persistency data
int	p_dialogs_hash_size
	size of the dialog hash table
p_dialog_hash_slot *	p_dialogs
	the hash table
db_con_t *	pcscf_db
	Database connection handle.
db_func_t	pcscf_dbf
	Structure with pointers to db functions.
int *	registrar_snapshot_version
	the version of the next registrar snapshot on the db
int *	registrar_step_version
	the step version within the current registrar snapshot version
int *	dialogs_snapshot_version
	the version of the next dialogs snapshot on the db
int *	dialogs_step_version
	the step version within the current dialogs snapshot version
int *	subs_snapshot_version
	the version of the next subscriptions snapshot on the db
int *	subs_step_version
	the step version within the current subscriptions snapshot version
gen_lock_t *	db_lock
	lock for db access
char *	pcscf_name
	SIP URI of this P-CSCF.
int	r_hash_size
	Size of P-CSCF registrar hash table.
r_hash_slot *	registrar
	The P-CSCF registrar.
int	subscriptions_hash_size
	Size of P-CSCF subscriptions hash table.
r_subscription_hash_slot *	subscriptions
	The P-CSCF subscriptions.
int	bin_db_keep_count = 1
	how many old snapshots to keep

---

Function Documentation

int p_dump	(	bin_data *	x,
		char *	location,
		char *	prepend_fname,
		data_type_t	dt
	)

Dumps P-CSCF data to files or DB.

Parameters:

	x	- binary data to dump. Empty if pcscf_persistency_mode==WITH_DATABASE_CACHE. In this case, each hashtable element is serialized and dumped to DB separately.
	location	-
	prepend_fname	-
	dt	- dump registrar, dialogs or susbcriptions

Returns:

1 on success or 0 on failure

Definition at line 374 of file p_persistency.c.

References bin_dump_to_db(), bin_dump_to_file(), M_NAME, NO_PERSISTENCY, NULL, pcscf_persistency_mode, WITH_DATABASE_BULK, WITH_DATABASE_CACHE, and WITH_FILES.

Referenced by make_snapshot_dialogs(), make_snapshot_registrar(), and make_snapshot_subscriptions().

                                                                            {
    switch (pcscf_persistency_mode){
        case NO_PERSISTENCY:
            LOG(L_ERR,"ERR:"M_NAME":p_dump: Snapshot done but persistency was disabled...\n");
            return 0;
        case WITH_FILES:
            return bin_dump_to_file(x,location,prepend_fname);
        case WITH_DATABASE_BULK:
            return bin_dump_to_db(x, dt);
        case WITH_DATABASE_CACHE:
            return bin_dump_to_db(NULL, dt); //ignore x, x is empty
        default:
            LOG(L_ERR,"ERR:"M_NAME":p_dump: Snapshot done but no such mode %d\n",pcscf_persistency_mode);
            return 0;
    }
}

int bin_dump_to_db	(	bin_data *	x,
		data_type_t	dt
	)

Dumps P-CSCF data to DB.

Parameters:

	x	- binary data to dump. NULL if scscf_persistency_mode==WITH_DATABASE_CACHE. In this case, each hashtable element is serialized and dumped to DB separately.
	dt	- dump registrar, dialogs or auth

Returns:

1 on success or 0 on failure

Definition at line 398 of file p_persistency.c.

References bin_dump_dialogs_to_table(), bin_dump_registrar_to_table(), bin_dump_subs_to_table(), dialogs_snapshot_version, dialogs_step_version, M_NAME, P_DIALOGS, P_REGISTRAR, P_SUBSCRIPTIONS, registrar_snapshot_version, registrar_step_version, subs_snapshot_version, and subs_step_version.

Referenced by p_dump(), and s_dump().

                                               {

    int snapshot_version;
    int step_version;
    
    switch(dt){
        case P_REGISTRAR:
            snapshot_version=*registrar_snapshot_version;
            step_version=*registrar_step_version;
            return bin_dump_registrar_to_table(x, snapshot_version, step_version);
        case P_DIALOGS:
            snapshot_version=*dialogs_snapshot_version;
            step_version=*dialogs_step_version;
            return bin_dump_dialogs_to_table(x, snapshot_version, step_version);
        case P_SUBSCRIPTIONS:
            snapshot_version=*subs_snapshot_version;
            step_version=*subs_step_version;
            return bin_dump_subs_to_table(x, snapshot_version, step_version);
        default:
            LOG(L_ERR,"ERR:"M_NAME":bin_dump_to_db: No such information to dump %d\n", dt);
            return 0;
    }
}

int bin_dump_registrar_to_table	(	bin_data *	x,
		int	snapshot_version,
		int	step_version
	)

Dumps P-CSCF registrar to DB.

Parameters:

	x	- binary data to dump. NULL if scscf_persistency_mode==WITH_DATABASE_CACHE. In this case, each hashtable element is serialized and dumped to DB separately.
	snapshot_version	- version of the current snapshot
	step_version	- the step in the current snapshot

Returns:

1 on success or 0 on failure

Definition at line 430 of file p_persistency.c.

References bin_bulk_dump_to_table(), bin_cache_dump_registrar_to_table(), and P_REGISTRAR.

Referenced by bin_dump_to_db().

                                                                                    {
    
    if(x){//whole hashtable serialized to x
        return bin_bulk_dump_to_table(P_REGISTRAR, snapshot_version, step_version, x);
    }
    else{//serialize and dump each hashtable element separately
        return bin_cache_dump_registrar_to_table(snapshot_version, step_version);
    }
}

int bin_dump_dialogs_to_table	(	bin_data *	x,
		int	snapshot_version,
		int	step_version
	)

Dumps P-CSCF dialogs to DB.

Parameters:

	x	- binary data to dump. NULL if scscf_persistency_mode==WITH_DATABASE_CACHE. In this case, each hashtable element is serialized and dumped to DB separately.
	snapshot_version	- version of the current snapshot
	step_version	- the step in the current snapshot

Returns:

1 on success or 0 on failure

Definition at line 448 of file p_persistency.c.

References bin_bulk_dump_to_table(), bin_cache_dump_dialogs_to_table(), and P_DIALOGS.

Referenced by bin_dump_to_db().

                                                                                  {
    
    if(x){//whole hashtable serialized to x
        return bin_bulk_dump_to_table(P_DIALOGS, snapshot_version, step_version, x);
    }
    else{//serialize and dump each hashtable element separately
        return bin_cache_dump_dialogs_to_table(snapshot_version, step_version);
    }
}

int bin_dump_subs_to_table	(	bin_data *	x,
		int	snapshot_version,
		int	step_version
	)

Dumps P-CSCF subscriptions to DB.

Parameters:

	x	- binary data to dump. NULL if pcscf_persistency_mode==WITH_DATABASE_CACHE. In this case, each hashtable element is serialized and dumped to DB separately.
	snapshot_version	- version of the current snapshot
	step_version	- the step in the current snapshot

Returns:

1 on success or 0 on failure

Definition at line 466 of file p_persistency.c.

References bin_bulk_dump_to_table(), bin_cache_dump_subs_to_table(), and P_SUBSCRIPTIONS.

Referenced by bin_dump_to_db().

                                                                               {
    
    if(x){//whole hashtable serialized to x
        return bin_bulk_dump_to_table(P_SUBSCRIPTIONS, snapshot_version, step_version, x);
    }
    else{//serialize and dump each hashtable element separately
        return bin_cache_dump_subs_to_table(snapshot_version, step_version);
    }
}

int bin_bulk_dump_to_table	(	data_type_t	dt,
		int	snapshot_version,
		int	step_version,
		bin_data *	x
	)

Dumps P-CSCF data to the snapshot table.

Parameters:

	dt	- dump registrar, dialogs or auth
	snapshot_version	- version of the current snapshot
	step_version	- the step in the current snapshot
	x	- binary data to dump (the whole hashtable).

Returns:

1 on success or 0 on failure

Definition at line 484 of file p_persistency.c.

References db_lock, delete_older_snapshots(), _bin_data::len, M_NAME, pcscf_db, pcscf_dbf, pcscf_name, and _bin_data::s.

Referenced by bin_dump_auth_to_table(), bin_dump_dialogs_to_table(), bin_dump_registrar_to_table(), and bin_dump_subs_to_table().

                                                                                               {
    db_key_t keys[5];
    db_val_t vals[5];
    int len;

    /* id auto incremented */
    keys[0] = "node_id";
    keys[1] = "data_type";
    keys[2] = "snapshot_version";
    keys[3] = "step_version";
    /* record_id_1/2/3/4=NULL */
    keys[4] = "data";
    
    vals[0].type = DB_STR;
    vals[0].nul = 0;
    vals[0].val.str_val.s=pcscf_name;
    len = strlen(pcscf_name);
    vals[0].val.str_val.len=MIN(len, 64);

    vals[1].type = DB_INT;
    vals[1].nul = 0;
    vals[1].val.int_val=dt;

    vals[2].type = DB_INT;
    vals[2].nul = 0;
    vals[2].val.int_val=snapshot_version;
    
    vals[3].type = DB_INT;
    vals[3].nul = 0;
    vals[3].val.int_val=step_version;

    str d = {x->s, x->len};
    vals[4].type = DB_BLOB;
    vals[4].nul = 0;
    vals[4].val.blob_val = d;

    //lock
    lock_get(db_lock);

    if (pcscf_dbf.use_table(pcscf_db, "snapshot") < 0) {
        LOG(L_ERR, "ERR:"M_NAME":bin_bulk_dump_to_table(): Error in use_table\n");
        lock_release(db_lock);//unlock
        return 0;
    }

    if (pcscf_dbf.insert(pcscf_db, keys, vals, 5) < 0) {
        LOG(L_ERR, "ERR:"M_NAME":bin_bulk_dump_to_table(): Error while inserting on snapshot table\n");
        lock_release(db_lock);//unlock
        return 0;
    }
    
    //delete older snapshots
    if (delete_older_snapshots("snapshot", pcscf_name, dt, snapshot_version)!=1){
        LOG(L_ERR, "ERR:"M_NAME":bin_bulk_dump_to_table(): Error while deleting older snapshots from snapshot table\n");
        lock_release(db_lock);//unlock
        return 0;
    }
    
    //unlock
    lock_release(db_lock);
    
    return 1;
}

int bin_cache_dump_registrar_to_table	(	int	snapshot_version,
		int	step_version
	)

Dumps P-CSCF registrar to the snapshot table.

Each r_public is serialized and dumped to one row of the table.

Parameters:

	snapshot_version	- version of the current snapshot
	step_version	- the step in the current snapshot

Returns:

1 on success or 0 on failure

Definition at line 555 of file p_persistency.c.

References bin_alloc(), bin_encode_r_contact(), bin_free(), db_lock, delete_older_snapshots(), r_hash_slot::head, _r_contact::host, _bin_data::len, M_NAME, _r_contact::next, P_REGISTRAR, pcscf_db, pcscf_dbf, pcscf_name, _r_contact::port, r_hash_size, r_lock(), r_unlock(), registrar, _bin_data::s, and _r_contact::transport.

Referenced by bin_dump_registrar_to_table().

                                                                             {
    bin_data x;
    r_contact *contact;
    int i;
    int len;
    char aux1[10];
    char aux2[10];
    
    //lock
    lock_get(db_lock);

    if (pcscf_dbf.use_table(pcscf_db, "snapshot") < 0) {
        LOG(L_ERR, "ERR:"M_NAME":bin_cache_dump_registrar_to_table(): Error in use_table\n");
        goto error;
    }
    
    for(i=0;i<r_hash_size;i++){
        r_lock(i);
        contact = registrar[i].head;
        while(contact){
            if (!bin_alloc(&x,128)){
                r_unlock(i);
                goto error;
            }
            if (!bin_encode_r_contact(&x,contact)){
                r_unlock(i);
                goto error;
            }
            
            db_key_t keys[8];
            db_val_t vals[8];
            
            /* id auto incremented */
            keys[0] = "node_id";
            keys[1] = "data_type";
            keys[2] = "snapshot_version";
            keys[3] = "step_version";
            keys[4] = "record_id_1"; /* host */
            keys[5] = "record_id_2"; /* port */
            keys[6] = "record_id_3"; /* transport */
            /* record_id_4=NULL */
            keys[7] = "data";
            
            vals[0].type = DB_STR;
            vals[0].nul = 0;
            vals[0].val.str_val.s=pcscf_name;
            len = strlen(pcscf_name);
            vals[0].val.str_val.len=MIN(len, 64);

            vals[1].type = DB_INT;
            vals[1].nul = 0;
            vals[1].val.int_val=P_REGISTRAR;

            vals[2].type = DB_INT;
            vals[2].nul = 0;
            vals[2].val.int_val=snapshot_version;
    
            vals[3].type = DB_INT;
            vals[3].nul = 0;
            vals[3].val.int_val=step_version;
    
            vals[4].type = DB_STR;
            vals[4].nul = 0;
            vals[4].val.str_val.s=contact->host.s;
            vals[4].val.str_val.len=MIN(contact->host.len, 256);
            
            vals[5].type = DB_STR;
            vals[5].nul = 0;
            sprintf(aux1, "%d", contact->port);
            vals[5].val.str_val.s=aux1;
            vals[5].val.str_val.len=strlen(aux1);
    
            vals[6].type = DB_STR;
            vals[6].nul = 0;
            sprintf(aux2, "%d", contact->transport);
            vals[6].val.str_val.s=aux2;
            vals[6].val.str_val.len=strlen(aux2);
        
            vals[7].type = DB_BLOB;
            vals[7].nul = 0;
            str data={x.s, x.len};
            vals[7].val.blob_val = data;
            
            if (pcscf_dbf.insert(pcscf_db, keys, vals, 8) < 0) {
                LOG(L_ERR, "ERR:"M_NAME":bin_cache_dump_registrar_to_table(): Error while inserting on snapshot table\n");
                r_unlock(i);
                goto error;
            }
            bin_free(&x);
            
            contact = contact->next;
        }
        r_unlock(i);
    }   
    
    //delete older snapshots
    if (delete_older_snapshots("snapshot", pcscf_name, P_REGISTRAR, snapshot_version)!=1){
        LOG(L_ERR, "ERR:"M_NAME":bin_cache_dump_registrar_to_table(): Error while deleting older snapshots from snapshot table\n");
        goto error;
    }
    
    //unlock
    lock_release(db_lock);
    
    return 1;

error:
    lock_release(db_lock);//unlock
    return 0;
}

int bin_cache_dump_dialogs_to_table	(	int	snapshot_version,
		int	step_version
	)

Dumps P-CSCF dialogs to the snapshot table.

Each dialog is serialized and dumped to one row of the table.

Parameters:

	snapshot_version	- version of the current snapshot
	step_version	- the step in the current snapshot

Returns:

1 on success or 0 on failure

Definition at line 673 of file p_persistency.c.

References bin_alloc(), bin_encode_p_dialog(), bin_free(), _p_dialog::call_id, d_lock(), d_unlock(), db_lock, delete_older_snapshots(), p_dialog_hash_slot::head, _p_dialog::host, _bin_data::len, M_NAME, _p_dialog::next, P_DIALOGS, p_dialogs, p_dialogs_hash_size, pcscf_db, pcscf_dbf, pcscf_name, _p_dialog::port, _bin_data::s, and _p_dialog::transport.

Referenced by bin_dump_dialogs_to_table().

                                                                           {
    bin_data x;
    p_dialog *dialog;
    int i;
    int len;
    char aux1[10];
    char aux2[10];
    
    //lock
    lock_get(db_lock);

    if (pcscf_dbf.use_table(pcscf_db, "snapshot") < 0) {
        LOG(L_ERR, "ERR:"M_NAME":bin_cache_dump_dialogs_to_table(): Error in use_table\n");
        goto error;
    }
    
    for(i=0;i<p_dialogs_hash_size;i++){
        d_lock(i);
        dialog = p_dialogs[i].head;
        while(dialog){
            if (!bin_alloc(&x,128)){
                d_unlock(i);
                goto error;
            }
            if (!bin_encode_p_dialog(&x,dialog)){
                d_unlock(i);
                goto error;
            }
            
            db_key_t keys[9];
            db_val_t vals[9];
            
            /* id auto incremented */
            keys[0] = "node_id";
            keys[1] = "data_type";
            keys[2] = "snapshot_version";
            keys[3] = "step_version";
            keys[4] = "record_id_1"; /* call-id */
            keys[5] = "record_id_2"; /* host */
            keys[6] = "record_id_3"; /* port */
            keys[7] = "record_id_4"; /* transport */
            keys[8] = "data";
            
            vals[0].type = DB_STR;
            vals[0].nul = 0;
            vals[0].val.str_val.s=pcscf_name;
            len = strlen(pcscf_name);
            vals[0].val.str_val.len=MIN(len, 64);

            vals[1].type = DB_INT;
            vals[1].nul = 0;
            vals[1].val.int_val=P_DIALOGS;

            vals[2].type = DB_INT;
            vals[2].nul = 0;
            vals[2].val.int_val=snapshot_version;
    
            vals[3].type = DB_INT;
            vals[3].nul = 0;
            vals[3].val.int_val=step_version;
    
            vals[4].type = DB_STR;
            vals[4].nul = 0;
            vals[4].val.str_val.s=dialog->call_id.s;
            vals[4].val.str_val.len=MIN(dialog->call_id.len, 256);
    
            vals[5].type = DB_STR;
            vals[5].nul = 0;
            vals[5].val.str_val.s=dialog->host.s;
            vals[5].val.str_val.len=MIN(dialog->host.len, 256);
            
            vals[6].type = DB_STR;
            vals[6].nul = 0;
            sprintf(aux1, "%d", dialog->port);
            vals[6].val.str_val.s=aux1;
            vals[6].val.str_val.len=strlen(aux1);
    
            vals[7].type = DB_STR;
            vals[7].nul = 0;
            sprintf(aux2, "%d", dialog->transport);
            vals[7].val.str_val.s=aux2;
            vals[7].val.str_val.len=strlen(aux2);
    
            vals[8].type = DB_BLOB;
            vals[8].nul = 0;
            str data={x.s, x.len};
            vals[8].val.blob_val = data;
            
            if (pcscf_dbf.insert(pcscf_db, keys, vals, 9) < 0) {
                LOG(L_ERR, "ERR:"M_NAME":bin_cache_dump_dialogs_to_table(): Error while inserting on snapshot table\n");
                d_unlock(i);
                goto error;
            }
            bin_free(&x);
            
            dialog = dialog->next;
        }
        d_unlock(i);
    }   
    
    //delete older snapshots
    if (delete_older_snapshots("snapshot", pcscf_name, P_DIALOGS, snapshot_version)!=1){
        LOG(L_ERR, "ERR:"M_NAME":bin_cache_dump_dialogs_to_table(): Error while deleting older snapshots from snapshot table\n");
        goto error;
    }
    
    //unlock
    lock_release(db_lock);
    
    return 1;

error:
    lock_release(db_lock);//unlock
    return 0;
}

int bin_cache_dump_subs_to_table	(	int	snapshot_version,
		int	step_version
	)

Dumps P-CSCF subscriptions to the snapshot table.

Each subscription is serialized and dumped to one row of the table.

Parameters:

	snapshot_version	- version of the current snapshot
	step_version	- the step in the current snapshot

Returns:

1 on success or 0 on failure

Definition at line 796 of file p_persistency.c.

References bin_alloc(), bin_encode_r_subscription(), bin_free(), db_lock, delete_older_snapshots(), r_subscription_hash_slot::head, _bin_data::len, M_NAME, _r_subscription::next, P_SUBSCRIPTIONS, pcscf_db, pcscf_dbf, pcscf_name, _r_subscription::req_uri, _bin_data::s, subs_lock(), subs_unlock(), subscriptions, and subscriptions_hash_size.

Referenced by bin_dump_subs_to_table().

                                                                        {
    bin_data x;
    r_subscription *sub;
    int i;
    int len;
    
    //lock
    lock_get(db_lock);

    if (pcscf_dbf.use_table(pcscf_db, "snapshot") < 0) {
        LOG(L_ERR, "ERR:"M_NAME":bin_cache_dump_subs_to_table(): Error in use_table\n");
        goto error;
    }
    
    for(i=0;i<subscriptions_hash_size;i++){
        subs_lock(i);
        sub = subscriptions[i].head;
        while(sub){
            if (!bin_alloc(&x,128)){
                subs_unlock(i);
                goto error;
            }
            if (!bin_encode_r_subscription(&x,sub)){
                subs_unlock(i);
                goto error;
            }
            
            db_key_t keys[6];
            db_val_t vals[6];
            
            /* id auto incremented */
            keys[0] = "node_id";
            keys[1] = "data_type";
            keys[2] = "snapshot_version";
            keys[3] = "step_version";
            keys[4] = "record_id_1"; /* req_uri */
            /* record_id_2/3/4=NULL*/
            keys[5] = "data";
            
            vals[0].type = DB_STR;
            vals[0].nul = 0;
            vals[0].val.str_val.s=pcscf_name;
            len = strlen(pcscf_name);
            vals[0].val.str_val.len=MIN(len, 64);

            vals[1].type = DB_INT;
            vals[1].nul = 0;
            vals[1].val.int_val=P_SUBSCRIPTIONS;

            vals[2].type = DB_INT;
            vals[2].nul = 0;
            vals[2].val.int_val=snapshot_version;
    
            vals[3].type = DB_INT;
            vals[3].nul = 0;
            vals[3].val.int_val=step_version;
    
            vals[4].type = DB_STR;
            vals[4].nul = 0;
            vals[4].val.str_val.s=sub->req_uri.s;
            vals[4].val.str_val.len=MIN(sub->req_uri.len, 256);
    
            vals[5].type = DB_BLOB;
            vals[5].nul = 0;
            str data={x.s, x.len};
            vals[5].val.blob_val = data;
            
            if (pcscf_dbf.insert(pcscf_db, keys, vals, 6) < 0) {
                LOG(L_ERR, "ERR:"M_NAME":bin_cache_dump_subscriptions_to_table(): Error while inserting on snapshot table\n");
                subs_unlock(i);
                goto error;
            }
            bin_free(&x);
            
            sub = sub->next;
        }
        subs_unlock(i);
    }   
    
    //delete older snapshots
    if (delete_older_snapshots("snapshot", pcscf_name, P_SUBSCRIPTIONS, snapshot_version)!=1){
        LOG(L_ERR, "ERR:"M_NAME":bin_cache_dump_subscriptions_to_table(): Error while deleting older snapshots from snapshot table\n");
        goto error;
    }
    
    //unlock
    lock_release(db_lock);
    
    return 1;

error:
    lock_release(db_lock);//unlock
    return 0;
}

int delete_older_snapshots	(	char *	table,
		char *	node_id,
		data_type_t	dt,
		int	current_snapshot
	)

Drops older subscriptions/dialogs/registrar snapshots, keeping the 'bin_db_keep_count' most recent.

Parameters:

	table	- where to drop.
	node_id	- cscf id
	dt	- which data to drop
	current_snapshot_version	- version of the current snapshot

Returns:

1 on success or 0 on failure

Definition at line 903 of file p_persistency.c.

References bin_db_keep_count, M_NAME, pcscf_db, and pcscf_dbf.

Referenced by bin_bulk_dump_to_table(), bin_cache_dump_auth_to_table(), bin_cache_dump_dialogs_to_table(), bin_cache_dump_registrar_to_table(), and bin_cache_dump_subs_to_table().

                                                                                            {

    db_key_t query_cols[3];
    db_op_t  query_ops[3];
    db_val_t query_vals[3];
    int len;

    query_cols[0] = "snapshot_version";
    query_ops[0] = OP_LEQ;
    query_vals[0].type = DB_INT;
    query_vals[0].nul = 0;
    query_vals[0].val.int_val = current_snapshot - bin_db_keep_count;
    
    query_cols[1] = "node_id";
    query_ops[1] = OP_EQ;
    query_vals[1].type = DB_STR;
    query_vals[1].nul = 0;
    len = strlen(node_id);
    query_vals[1].val.str_val.s=node_id;
    query_vals[1].val.str_val.len=MIN(len, 256);
    
    query_cols[2] = "data_type";
    query_ops[2] = OP_EQ;
    query_vals[2].type = DB_INT;
    query_vals[2].nul = 0;
    query_vals[2].val.int_val = dt;

    if (pcscf_dbf.use_table(pcscf_db, table) < 0) {
        LOG(L_ERR, "ERR:"M_NAME":delete_older_snapshots(): Error in use_table\n");
        return 0;
    }

    if (pcscf_dbf.delete(pcscf_db, query_cols, query_ops, query_vals, 3) < 0) {
        LOG(L_ERR, "ERR:"M_NAME":delete_older_snapshots(): Error while deleting older snapshots\n");
        return 0;
    }
    
    return 1;
}

int p_load	(	bin_data *	x,
		char *	location,
		char *	prepend_fname,
		data_type_t	dt
	)

Loads P-CSCF data from files or DB.

Parameters:

	x	- destination of the loaded data. Empty if pcscf_persistency_mode==WITH_DATABASE_CACHE. In this case, each row of the table is loaded and placed on the hashtable now, instead of to be passed to load_snapshot_...() function, which does this work when the whole hashtable was dumped to only one row of the table.
	location	-
	prepend_fname	-
	dt	- load registrar, dialogs or susbcriptions

Returns:

1 on success or 0 on failure

Definition at line 956 of file p_persistency.c.

References bin_load_from_db(), bin_load_from_file(), M_NAME, NO_PERSISTENCY, NULL, pcscf_persistency_mode, WITH_DATABASE_BULK, WITH_DATABASE_CACHE, and WITH_FILES.

Referenced by load_snapshot_dialogs(), load_snapshot_registrar(), and load_snapshot_subscriptions().

                                                                            {
    switch (pcscf_persistency_mode){
        case NO_PERSISTENCY:
            LOG(L_ERR,"ERR:"M_NAME":p_load: Persistency support was disabled\n");
            return 0;
        case WITH_FILES:
            return bin_load_from_file(x,location,prepend_fname);        
        case WITH_DATABASE_BULK:
            return bin_load_from_db(x, dt);
        case WITH_DATABASE_CACHE:
            return bin_load_from_db(NULL, dt); //ignore x, x is empty
        default:
            LOG(L_ERR,"ERR:"M_NAME":p_load: Can't resume because no such mode %d\n",pcscf_persistency_mode);
            return 0;
    }
}

int bin_load_from_db	(	bin_data *	x,
		data_type_t	dt
	)

Loads P-CSCF data from DB.

Parameters:

	x	- Destination of the data.
	dt	- load registrar, dialogs or auth

Returns:

1 on success or 0 on failure

Definition at line 979 of file p_persistency.c.

References bin_load_dialogs_from_table(), bin_load_registrar_from_table(), bin_load_subscriptions_from_table(), M_NAME, P_DIALOGS, P_REGISTRAR, and P_SUBSCRIPTIONS.

Referenced by p_load(), and s_load().

                                                 {
    switch(dt){
        case P_REGISTRAR:
            return bin_load_registrar_from_table(x);
        case P_DIALOGS:
            return bin_load_dialogs_from_table(x);
        case P_SUBSCRIPTIONS:
            return bin_load_subscriptions_from_table(x);
        default:
            LOG(L_ERR,"ERR:"M_NAME":bin_load_from_db: No such information to load %d\n", dt);
            return 0;
    }
}

int bin_load_registrar_from_table

(

bin_data *

x

)

Loads P-CSCF registrar from DB.

Parameters:

x

- Destination of the data

Returns:

1 on success or 0 on failure

Definition at line 998 of file p_persistency.c.

References bin_bulk_load_from_table(), bin_cache_load_registrar_from_table(), and P_REGISTRAR.

Referenced by bin_load_from_db().

                                              {
    if(x){//whole hashtable dumped to db
        return bin_bulk_load_from_table(P_REGISTRAR, x);
    }
    else{//each hashtable element dumped to DB separately
        return bin_cache_load_registrar_from_table();
    }
}

int bin_load_dialogs_from_table

(

bin_data *

x

)

Loads P-CSCF dialogs from DB.

Parameters:

x

- Destination of the data

Returns:

1 on success or 0 on failure

Definition at line 1012 of file p_persistency.c.

References bin_bulk_load_from_table(), bin_cache_load_dialogs_from_table(), and P_DIALOGS.

Referenced by bin_load_from_db().

                                            {
    if(x){//whole hashtable dumped to db
        return bin_bulk_load_from_table(P_DIALOGS, x);
    }
    else{//each hashtable element dumped to DB separately
        return bin_cache_load_dialogs_from_table();
    }
}

int bin_load_subscriptions_from_table

(

bin_data *

x

)

Loads P-CSCF subscriptions from DB.

Parameters:

x

- Destination of the data

Returns:

1 on success or 0 on failure

Definition at line 1026 of file p_persistency.c.

References bin_bulk_load_from_table(), bin_cache_load_subscriptions_from_table(), and P_SUBSCRIPTIONS.

Referenced by bin_load_from_db().

                                                  {
    if(x){//whole hashtable dumped to db
        return bin_bulk_load_from_table(P_SUBSCRIPTIONS, x);
    }
    else{//each hashtable element dumped to DB separately
        return bin_cache_load_subscriptions_from_table();
    }
}

int bin_bulk_load_from_table	(	data_type_t	dt,
		bin_data *	x
	)

Loads P-CSCF data from the snapshot table.

Parameters:

	dt	- load registrar, dialogs or auth
	x	- where to load

Returns:

1 on success or 0 on failure

Definition at line 1041 of file p_persistency.c.

References bin_alloc(), bin_expand(), db_get_last_snapshot_version(), db_lock, _bin_data::len, M_NAME,