/**
* The Subscription timer looks for almost expired subscriptions and subscribes again.
* @param ticks - the current time
* @param param - the generic parameter
*/
void subscription_timer(unsigned int ticks, void* param)
{
r_subscription *s,*ns;
int i;
#ifdef WITH_IMS_PM
int subs_cnt=0;
#endif
for(i=0;i<subscriptions_hash_size;i++){
subs_lock(i);
s = subscriptions[i].head;
r_act_time();
while(s){
ns = s->next;
if (s->attempts_left > 0 ){
/* attempt to send a subscribe */
if (!r_send_subscribe(s,s->duration)){
LOG(L_ERR,"ERR:"M_NAME":subscription_timer: Error on SUBSCRIBE (%d times)... droping\n",
pcscf_subscribe_retries);
del_r_subscription_nolock(s);
}else{
s->attempts_left--;
#ifdef WITH_IMS_PM
subs_cnt++;
#endif
}
}else if (s->attempts_left==0) {
/* we failed to many times, drop the subscription */
LOG(L_ERR,"ERR:"M_NAME":subscription_timer: Error on SUBSCRIBE for %d times... aborting\n",pcscf_subscribe_retries);
del_r_subscription_nolock(s);
}else{
/* we are subscribed already */
/* if expired, drop it */
if (s->expires<time_now)
del_r_subscription_nolock(s);
#ifdef WITH_IMS_PM
else subs_cnt++;
#endif
/* if not expired, check for renewal */
// Commented as the S-CSCF should adjust the subscription time accordingly
// if ((s->duration<1200 && s->expires-time_now<s->duration/2)||
// (s->duration>=1200 && s->expires-time_now<600))
// {
// /* if we need a resubscribe, we mark it as such and try to subscribe again */
// s->attempts_left = pcscf_subscribe_retries;
// ns = s;
// }
}
s = ns;
}
subs_unlock(i);
}
print_subs(L_INFO);
#ifdef WITH_IMS_PM
IMS_PM_LOG01(RD_NbrSubs,subs_cnt);
#endif
}
int send_subscribe(subs_info_t* subs)
{
ua_pres_t* presentity= NULL;
str met= {"SUBSCRIBE", 9};
str* str_hdr= NULL;
int ret= -1;
unsigned int hash_code=0;
ua_pres_t* hentity= NULL;
int expires;
int flag;
int result;
uac_req_t uac_r;
db1_res_t *res=NULL;
ua_pres_t dbpres;
str pres_uri={0,0}, watcher_uri={0,0}, extra_headers={0,0};
dlg_t* td= NULL;
memset(&dbpres, 0, sizeof(dbpres));
dbpres.pres_uri = &pres_uri;
dbpres.watcher_uri = &watcher_uri;
dbpres.extra_headers = &extra_headers;
print_subs(subs);
flag= subs->source_flag;
if(subs->source_flag & XMPP_INITIAL_SUBS)
subs->source_flag= XMPP_SUBSCRIBE;
if(subs->expires< 0)
expires= 3600;
else
expires= subs->expires;
str_hdr= subs_build_hdr(subs->contact, expires, subs->event,
subs->extra_headers);
if(str_hdr== NULL || str_hdr->s== NULL)
{
LM_ERR("while building extra headers\n");
return -1;
}
if (dbmode == PUA_DB_ONLY && pua_dbf.start_transaction)
{
if (pua_dbf.start_transaction(pua_db, db_table_lock) < 0)
{
LM_ERR("in start_transaction\n");
goto error;
}
}
/* generation of hash and getting lock moved from here to further down */
if (dbmode==PUA_DB_ONLY)
{
presentity = get_dialog_puadb(subs->id, subs->pres_uri, &dbpres, &res);
}
else
{
ua_pres_t pres;
memset(&pres, 0, sizeof(ua_pres_t));
pres.pres_uri = subs->pres_uri;
pres.watcher_uri = subs->watcher_uri;
pres.flag = subs->source_flag;
pres.id = subs->id;
pres.event = subs->event;
if (subs->remote_target)
pres.remote_contact = *subs->remote_target;
hash_code=core_hash(subs->pres_uri, subs->watcher_uri, HASH_SIZE);
lock_get(&HashT->p_records[hash_code].lock);
presentity= search_htable(&pres, hash_code);
}
/* if flag == INSERT_TYPE insert no matter what the search result is */
if(subs->flag & INSERT_TYPE)
{
LM_DBG("A subscription request with insert type\n");
goto insert;
}
if(presentity== NULL )
{
int size;
insert:
if (subs->expires == 0)
{
/* Don't create a new dialog when expires == 0 */
if (dbmode != PUA_DB_ONLY)
lock_release(&HashT->p_records[hash_code].lock);
goto done;
}
if(subs->flag & UPDATE_TYPE)
{
LM_DBG("request for a subscription with update type"
" and no record found\n");
subs->flag= INSERT_TYPE;
}
hentity= subscribe_cbparam(subs, REQ_OTHER);
if(hentity== NULL)
{
LM_ERR("while building callback"
" param\n");
if (dbmode != PUA_DB_ONLY)
lock_release(&HashT->p_records[hash_code].lock);
goto error;
}
hentity->flag= flag;
set_uac_req(&uac_r, &met, str_hdr, 0, 0, TMCB_LOCAL_COMPLETED,
subs_cback_func, (void*)hentity);
result= tmb.t_request_outside
(&uac_r, /* Type of the message */
subs->remote_target?subs->remote_target:subs->pres_uri,/* Request-URI*/
subs->pres_uri, /* To */
subs->watcher_uri, /* From */
subs->outbound_proxy /* Outbound_proxy */
);
if(result< 0)
{
LM_ERR("while sending request with t_request\n");
if (uac_r.dialog != NULL)
{
uac_r.dialog->rem_target.s = 0;
uac_r.dialog->dst_uri.s = 0;
tmb.free_dlg(uac_r.dialog);
uac_r.dialog = 0;
}
shm_free(hentity);
if (dbmode != PUA_DB_ONLY)
lock_release(&HashT->p_records[hash_code].lock);
/* Although this is an error must not return -1 as the
calling function must continue processing. */
ret = 0;
goto error;
}
/* Now create a temporary hash table entry.
This is needed to deal with the race-hazard when NOTIFYs
arrive before the 2xx response to the SUBSCRIBE. */
size = sizeof(ua_pres_t)+ 2 * sizeof(str) + (
subs->pres_uri->len +
subs->watcher_uri->len +
uac_r.dialog->id.loc_tag.len +
uac_r.dialog->id.call_id.len +
subs->id.len) * sizeof(char);
presentity= (ua_pres_t*)shm_malloc(size);
if(presentity== NULL)
{
LM_ERR("no more share memory\n");
if (dbmode != PUA_DB_ONLY)
lock_release(&HashT->p_records[hash_code].lock);
goto error;
}
memset(presentity, 0, size);
size= sizeof(ua_pres_t);
presentity->pres_uri = (str *) ((char *) presentity + size);
size += sizeof(str);
presentity->pres_uri->s= (char *) presentity + size;
memcpy(presentity->pres_uri->s, subs->pres_uri->s, subs->pres_uri->len);
presentity->pres_uri->len= subs->pres_uri->len;
size+= subs->pres_uri->len;
presentity->watcher_uri= (str *) ((char *) presentity + size);
size += sizeof(str);
presentity->watcher_uri->s= (char *) presentity + size;
memcpy(presentity->watcher_uri->s, subs->watcher_uri->s, subs->watcher_uri->len);
presentity->watcher_uri->len = subs->watcher_uri->len;
size += subs->watcher_uri->len;
presentity->call_id.s = (char *) presentity + size;
memcpy(presentity->call_id.s, uac_r.dialog->id.call_id.s, uac_r.dialog->id.call_id.len);
presentity->call_id.len = uac_r.dialog->id.call_id.len;
size += uac_r.dialog->id.call_id.len;
presentity->from_tag.s = (char *) presentity + size;
memcpy(presentity->from_tag.s, uac_r.dialog->id.loc_tag.s, uac_r.dialog->id.loc_tag.len);
presentity->from_tag.len= uac_r.dialog->id.loc_tag.len;
size += uac_r.dialog->id.loc_tag.len;
presentity->id.s = (char *) presentity+ size;
memcpy(presentity->id.s, subs->id.s, subs->id.len);
presentity->id.len = subs->id.len;
size += subs->id.len;
presentity->event = subs->event;
presentity->flag = subs->source_flag;
presentity->cseq = uac_r.dialog->loc_seq.value;
/* Set the temporary record expiry for 2 * 64T1 seconds from now */
presentity->expires= (int)time(NULL) + 64;
presentity->desired_expires= presentity->expires;
if (dbmode==PUA_DB_ONLY)
{
insert_dialog_puadb(presentity);
shm_free(presentity);
}
else
{
insert_htable(presentity, hash_code);
lock_release(&HashT->p_records[hash_code].lock);
}
uac_r.dialog->rem_target.s = 0;
uac_r.dialog->dst_uri.s = 0;
tmb.free_dlg(uac_r.dialog);
uac_r.dialog = 0;
}
else
{
if (subs->internal_update_flag == INTERNAL_UPDATE_TRUE)
{
LM_INFO("attempting to re-SUBSCRIBE on internal (rls_update_subs()) update - skipping\n");
if (dbmode != PUA_DB_ONLY)
lock_release(&HashT->p_records[hash_code].lock);
goto done;
}
if (presentity->to_tag.len == 0)
{
if (subs->expires > 0)
LM_WARN("attempting to re-SUBSCRIBE to a temporary (non-established) dialog - skipping\n");
else
{
LM_WARN("attempting to un-SUBSCRIBE from a temporary (non-established) dialog - skipping and deleting dialog\n");
if (dbmode==PUA_DB_ONLY)
delete_dialog_puadb(presentity);
else
delete_htable(presentity, hash_code);
}
if (dbmode != PUA_DB_ONLY)
lock_release(&HashT->p_records[hash_code].lock);
goto done;
}
td= pua_build_dlg_t(presentity);
if(td== NULL)
{
LM_ERR("while building tm dlg_t structure");
if (dbmode!=PUA_DB_ONLY)
lock_release(&HashT->p_records[hash_code].lock);
goto error;
}
hentity= subs_cbparam_indlg(presentity, expires, REQ_OTHER);
if(hentity== NULL)
{
LM_ERR("while building callback param\n");
if (dbmode!=PUA_DB_ONLY)
lock_release(&HashT->p_records[hash_code].lock);
goto error;
}
if (dbmode!=PUA_DB_ONLY)
lock_release(&HashT->p_records[hash_code].lock);
LM_DBG("event parameter: %d\n", hentity->event);
set_uac_req(&uac_r, &met, str_hdr, 0, td, TMCB_LOCAL_COMPLETED,
subs_cback_func, (void*)hentity);
result= tmb.t_request_within(&uac_r);
if(result< 0)
{
shm_free(hentity);
hentity= NULL;
LM_ERR("while sending request with t_request\n");
goto error;
}
}
done:
if (dbmode == PUA_DB_ONLY && pua_dbf.end_transaction)
{
if (pua_dbf.end_transaction(pua_db) < 0)
{
LM_ERR("in end_transaction\n");
goto error;
}
}
ret = 0;
error:
pua_free_tm_dlg(td);
pkg_free(str_hdr);
free_results_puadb(res);
if (dbmode == PUA_DB_ONLY && pua_dbf.abort_transaction)
{
if (pua_dbf.abort_transaction(pua_db) < 0)
LM_ERR("in abort_transaction\n");
}
return ret;
}
int send_subscribe(subs_info_t* subs)
{
ua_pres_t* presentity= NULL;
str met= {"SUBSCRIBE", 9};
str* str_hdr= NULL;
int ret= 0;
unsigned int hash_index;
ua_pres_t* hentity= NULL, pres;
int expires;
int flag;
int result;
print_subs(subs);
flag= subs->source_flag;
if(subs->source_flag & XMPP_INITIAL_SUBS)
subs->source_flag= XMPP_SUBSCRIBE;
if(subs->expires< 0)
subs->expires = default_expires;
else
if(subs->expires!= 0 && subs->expires < min_expires)
subs->expires = min_expires;
expires = subs->expires;
if(subs->extra_headers)
LM_DBG("received extra_headers = %.*s\n",
subs->extra_headers->len, subs->extra_headers->s);
str_hdr= subs_build_hdr(subs->contact, expires, subs->event,
subs->extra_headers);
if(str_hdr== NULL || str_hdr->s== NULL)
{
LM_ERR("while building extra headers\n");
return -1;
}
memset(&pres, 0, sizeof(ua_pres_t));
pres.pres_uri = subs->pres_uri;
pres.watcher_uri= subs->watcher_uri;
if(subs->to_uri.s)
pres.to_uri = subs->to_uri;
else
{
pres.to_uri.s = subs->pres_uri->s;
pres.to_uri.len = subs->pres_uri->len;
}
pres.flag = subs->source_flag;
pres.id = subs->id;
pres.event = subs->event;
hash_index=core_hash(&pres.to_uri, pres.watcher_uri, HASH_SIZE);
lock_get(&HashT->p_records[hash_index].lock);
if(subs->flag != INSERT_TYPE)
presentity= search_htable(&pres, hash_index);
if(presentity== NULL )
{
lock_release(&HashT->p_records[hash_index].lock);
if(subs->flag & UPDATE_TYPE)
{
/*
LM_ERR("request for a subscription"
" with update type and no record found\n");
ret= -1;
goto done;
commented this because of the strange type parameter in usrloc callback functions
*/
LM_DBG("request for a subscription with update type"
" and no record found\n");
subs->flag= INSERT_TYPE;
}
hentity= subscribe_cbparam(subs, REQ_OTHER);
if(hentity== NULL)
{
LM_ERR("while building callback"
" param\n");
ret= -1;
goto done;
}
hentity->hash_index = hash_index;
hentity->flag= flag;
result= tmb.t_request
(&met, /* Type of the message */
pres.pres_uri, /* Request-URI*/
&pres.to_uri, /* To */
pres.watcher_uri, /* From */
str_hdr, /* Optional headers including CRLF */
0, /* Message body */
subs->outbound_proxy, /* Outbound_proxy */
subs_cback_func, /* Callback function */
(void*)hentity, /* Callback parameter */
0
);
if(result< 0)
{
LM_ERR("while sending request with t_request\n");
shm_free(hentity);
goto done;
}
}
else
{
/*
if(presentity->desired_expires== 0)
{
if(subs->expires< 0)
{
LM_DBG("Found previous request for unlimited subscribe-"
" do not send subscribe\n");
if (subs->event & PWINFO_EVENT)
{
presentity->watcher_count++;
}
lock_release(&HashT->p_records[hash_index].lock);
goto done;
}
if(subs->event & PWINFO_EVENT)
{
if(subs->expires== 0)
{
presentity->watcher_count--;
if( presentity->watcher_count> 0)
{
lock_release(&HashT->p_records[hash_index].lock);
goto done;
}
}
else
{
presentity->watcher_count++;
if(presentity->watcher_count> 1)
{
lock_release(&HashT->p_records[hash_index].lock);
goto done;
}
}
}
}
*/
dlg_t* td= NULL;
if (subs->internal_update_flag)
{
LM_DBG("attempting to re-SUBSCRIBE on internal dialog update - skipping\n");
lock_release(&HashT->p_records[hash_index].lock);
goto done;
}
if (presentity->to_tag.len == 0)
{
LM_WARN("attempting to re-SUBSCRIBE to temporary (non-established) dialog - skipping\n");
lock_release(&HashT->p_records[hash_index].lock);
goto done;
}
td= pua_build_dlg_t(presentity);
if(td== NULL)
{
LM_ERR("while building tm dlg_t structure");
ret= -1;
lock_release(&HashT->p_records[hash_index].lock);
goto done;
}
hentity= subs_cbparam_indlg(presentity, expires, REQ_OTHER);
if(hentity== NULL)
{
LM_ERR("while building callback param\n");
lock_release(&HashT->p_records[hash_index].lock);
ret= -1;
pkg_free(td);
goto done;
}
presentity->desired_expires = hentity->desired_expires;
lock_release(&HashT->p_records[hash_index].lock);
// hentity->flag= flag;
LM_DBG("event parameter: %d\n", hentity->event);
result= tmb.t_request_within
(&met,
str_hdr,
0,
td,
subs_cback_func,
(void*)hentity,
0
);
if(result< 0)
{
shm_free(hentity);
hentity= NULL;
LM_ERR("while sending request with t_request\n");
goto done;
}
if(td->route_set)
free_rr(&td->route_set);
pkg_free(td);
td= NULL;
}
done:
pkg_free(str_hdr);
return ret;
}
void
parse_file(PARROT_INTERP, int flexdebug, ARGIN(FILE *infile),
ARGIN(char * const filename), int flags,
int thr_id, unsigned macro_size,
ARGMOD_NULLOK(char * const outputfile))
{
ASSERT_ARGS(parse_file)
yyscan_t yyscanner;
lexer_state *lexer = NULL;
/* create a yyscan_t object */
yypirlex_init(&yyscanner);
/* set debug flag */
yypirset_debug(flexdebug, yyscanner);
/* set the input file */
yypirset_in(infile, yyscanner);
/* set the extra parameter in the yyscan_t structure */
lexer = new_lexer(interp, filename, flags);
lexer->macro_size = macro_size;
/* initialize the scanner state */
init_scanner_state(yyscanner);
if (strstr(filename, ".pasm")) { /* PASM mode */
SET_FLAG(lexer->flags, LEXER_FLAG_PASMFILE);
}
yypirset_extra(lexer, yyscanner);
/* and store the yyscanner in the lexer, so they're close buddies */
lexer->yyscanner = yyscanner;
/* go parse */
yypirparse(yyscanner, lexer);
if (lexer->parse_errors == 0) {
char outfile[20];
sprintf(outfile, "output_thr_%d", thr_id);
lexer->outfile = open_file(outfile, "w");
if (lexer->outfile == NULL) {
fprintf(stderr, "Failed to open file %s\n", outfile);
lexer->outfile = stdout;
}
if (TEST_FLAG(lexer->flags, LEXER_FLAG_NOOUTPUT)) /* handy for testing the compiler */
fprintf(stdout, "ok\n");
else if (TEST_FLAG(lexer->flags, LEXER_FLAG_PREPROCESS))
emit_pir_subs(lexer, outputfile);
else if (TEST_FLAG(lexer->flags, LEXER_FLAG_OUTPUTPBC))
emit_pbc(lexer, outputfile);
else
/*
fprintf(stderr, "Parse successful!\n");
*/
print_subs(lexer);
fclose(lexer->outfile);
if (TEST_FLAG(lexer->flags, LEXER_FLAG_WARNINGS))
check_unused_symbols(lexer);
}
/* there may have been errors during the instruction generation, check again here. */
if (lexer->parse_errors > 0)
fprintf(stderr, "There were %d errors\n", lexer->parse_errors);
fclose(infile);
/* XXX just want to make sure pirc doesn't segfault when doing bytecode stuff. */
/*
if (TEST_FLAG(lexer->flags, LEXER_FLAG_OUTPUTPBC))
fprintf(stderr, "pirc ok\n");
*/
/* clean up after playing */
release_resources(lexer);
yypirlex_destroy(yyscanner);
}
/*
=item C<void parse_string(PARROT_INTERP, char *pirstring, int flags, int
pasminput, unsigned macro_size)>
Parse a PIR string.
=cut
*/
void
parse_string(PARROT_INTERP, ARGIN(char *pirstring), int flags, int pasminput,
unsigned macro_size)
{
ASSERT_ARGS(parse_string)
yyscan_t yyscanner;
lexer_state *lexer = NULL;
char name[64];
PackFile_ByteCode *old_cs, *new_cs;
INTVAL eval_number;
if (eval_nr == 0)
MUTEX_INIT(eval_nr_lock);
LOCK(eval_nr_lock);
eval_number = ++eval_nr;
UNLOCK(eval_nr_lock);
snprintf(name, sizeof (name), "EVAL_" INTVAL_FMT, eval_number);
new_cs = PF_create_default_segs(interp, Parrot_str_new(interp, name, strlen(name)), 0);
old_cs = Parrot_switch_to_cs(interp, new_cs, 0);
/* create a yyscan_t object */
yypirlex_init(&yyscanner);
yypirset_debug(0, yyscanner);
/* set the extra parameter in the yyscan_t structure */
lexer = new_lexer(interp, name, flags);
lexer->macro_size = macro_size;
yypirset_extra(lexer, yyscanner);
lexer->yyscanner = yyscanner;
/* initialize the scanner state */
init_scanner_state(yyscanner);
/* set the scanner to a string buffer and go parse */
yypir_scan_string(pirstring, yyscanner);
if (pasminput) { /* PASM mode */
SET_FLAG(lexer->flags, LEXER_FLAG_PASMFILE);
}
yypirparse(yyscanner, lexer);
if (lexer->parse_errors == 0) {
print_subs(lexer);
if (TEST_FLAG(lexer->flags, LEXER_FLAG_WARNINGS))
check_unused_symbols(lexer);
}
/* there may have been errors during the instruction generation, check again here. */
if (lexer->parse_errors > 0)
fprintf(stderr, "There were %d errors\n", lexer->parse_errors);
/* XXX just want to make sure pirc doesn't segfault when doing bytecode stuff. */
if (TEST_FLAG(lexer->flags, LEXER_FLAG_OUTPUTPBC)) {
emit_pbc(lexer, NULL);
}
/*
fprintf(stderr, "ok\n");
*/
/* clean up after playing */
release_resources(lexer);
/* clean up after playing */
yypirlex_destroy(yyscanner);
}
int pwospf_init(struct sr_instance* sr)
{
assert(sr);
sr->ospf_subsys = (struct pwospf_subsys*)malloc(sizeof(struct pwospf_subsys));
assert(sr->ospf_subsys);
pthread_mutex_init(&(sr->ospf_subsys->lock), 0);
/* -- handle subsystem initialization here! -- */
create_pwospf_ifaces(sr);
char *eth0_interface = "eth0";
struct sr_if* zero = sr_get_interface(sr, eth0_interface);
sr->ospf_subsys->fwrd_table = 0;
sr->ospf_subsys->network = 0;
sr->ospf_subsys->this_router = add_new_router(sr, zero->ip);
sr->ospf_subsys->last_seq_sent=0;
if(zero == NULL)
{
printf("null\n");
}
int i = 0;
struct pwospf_iflist *cur_if = sr->ospf_subsys->interfaces;
struct ftable_entry* cur_ft_entry = NULL;
while(cur_if)
{
sr->ospf_subsys->this_router->subnets[i] = (struct route*)malloc(sizeof(struct route));
sr->ospf_subsys->this_router->subnets[i]->mask.s_addr = cur_if->mask.s_addr;
struct in_addr temp_add;
struct in_addr temp_mask;
temp_add.s_addr = cur_if->address.s_addr;
temp_mask.s_addr = sr->ospf_subsys->this_router->subnets[i]->mask.s_addr;
sr->ospf_subsys->this_router->subnets[i]->prefix.s_addr = (temp_add.s_addr & temp_mask.s_addr);
if((cur_if->address.s_addr & cur_if->mask.s_addr) == cur_if->address.s_addr)
{
sr->ospf_subsys->this_router->subnets[i]->next_hop.s_addr = ntohl((htonl(cur_if->address.s_addr) | 1 ));
}
else
{
sr->ospf_subsys->this_router->subnets[i]->next_hop.s_addr = (cur_if->address.s_addr & cur_if->mask.s_addr);
}
sr->ospf_subsys->this_router->subnets[i]->r_id = 0;
if(sr->ospf_subsys->fwrd_table == 0)
{
sr->ospf_subsys->fwrd_table = (struct ftable_entry*)malloc(sizeof(struct ftable_entry));
cur_ft_entry = sr->ospf_subsys->fwrd_table;
}
else
{
cur_ft_entry->next = (struct ftable_entry*)malloc(sizeof(struct ftable_entry));
cur_ft_entry = cur_ft_entry->next;
}
cur_ft_entry->prefix = sr->ospf_subsys->this_router->subnets[i]->prefix;
cur_ft_entry->mask = sr->ospf_subsys->this_router->subnets[i]->mask;
cur_ft_entry->next_hop = sr->ospf_subsys->this_router->subnets[i]->next_hop;
cur_ft_entry->num_hops = 0;
cur_ft_entry->next = 0;
memmove(cur_ft_entry->interface, cur_if->name, sr_IFACE_NAMELEN);
sr->ospf_subsys->this_router->subnet_size++;
i++;
cur_if = cur_if->next;
}
print_subs(sr->ospf_subsys->this_router->subnets, sr->ospf_subsys->this_router->subnet_size);
sr->ospf_subsys->last_seq_sent = 0;
sr->ospf_subsys->area_id = read_config(FILENAME); /* !!!! returns 0 if file read error !!!! */
sr->ospf_subsys->autype = 0;
sr->ospf_subsys->init_time= time(NULL) + TOP_INITIALIZATION;
print_topo(sr);
/* -- start thread subsystem -- */
if( pthread_create(&sr->ospf_subsys->thread, 0, pwospf_run_thread, sr)) {
perror("pthread_create");
assert(0);
}
return 0; /* success */
} /* -- pwospf_init -- */
