frd_stats_entry_t* get_stats(str user, str prefix, str *shm_user) { rw_lock_t *item_lock; /* First go one level below using the user key */ frd_users_map_item_t **hm = (frd_users_map_item_t **)get_item(&stats_table, user, &item_lock); if (*hm == NULL) { /* First time the user is seen, we must create a hashmap */ *hm = shm_malloc(sizeof(frd_users_map_item_t)); if (*hm == NULL) { lock_stop_write(item_lock); LM_ERR("no more shm memory\n"); return NULL; } lock_stop_write(item_lock); (*hm)->numbers_hm.size = FRD_PREFIX_HASH_SIZE; if (init_hash_map(&(*hm)->numbers_hm) != 0) { LM_ERR("cannot init hashmap\n"); shm_free(*hm); return NULL; } if (shm_str_dup(&(*hm)->user, &user) != 0) { free_hash_map(&(*hm)->numbers_hm, destroy_stats_entry); shm_free(*hm); return NULL; } } lock_stop_write(item_lock); if (shm_user) *shm_user = (*hm)->user; frd_stats_entry_t **stats_entry = (frd_stats_entry_t**)get_item(&(*hm)->numbers_hm, prefix, &item_lock); if (*stats_entry == NULL) { /* First time the prefix is seen for this user */ *stats_entry = shm_malloc(sizeof(frd_stats_entry_t)); if (*stats_entry == NULL) { lock_stop_write(item_lock); LM_ERR("no more shm memory\n"); return NULL; } lock_stop_write(item_lock); /* Now init the auxiliary info for a stats structure */ if (!lock_init(&(*stats_entry)->lock)) { LM_ERR ("cannot init lock\n"); shm_free(*stats_entry); return NULL; } memset(&((*stats_entry)->stats), 0, sizeof(frd_stats_t)); } lock_stop_write(item_lock); return *stats_entry; }
static struct lb_resource *add_lb_resource(struct lb_data *data, str *name) { #define PROFILE_MAX_NAME 256 char buf[PROFILE_MAX_NAME]; struct lb_resource *new_res; struct lb_resource *res; struct lb_resource *p_res; str profile_name; int o; LM_DBG(" new resource name=<%.*s>\n",name->len,name->s); new_res = (struct lb_resource*)shm_malloc ( sizeof(struct lb_resource) + name->len ); if (new_res==NULL) { LM_ERR("failed to allocate shm mem (%ld)\n", (unsigned long)(sizeof(struct lb_resource) + name->len) ); return NULL; } memset( new_res , 0 , sizeof(struct lb_resource)); new_res->name.s = (char*)(new_res+1); new_res->name.len = name->len; memcpy( new_res->name.s, name->s, name->len ); /* create & init lock */ if ( (new_res->lock=lock_alloc())==0) { LM_CRIT("failed to alloc lock\n"); goto error; } if (lock_init(new_res->lock)==0 ) { LM_CRIT("failed to init lock\n"); goto error; } /* create and get new dialog profile */ profile_name.len = snprintf( buf, PROFILE_MAX_NAME-1, "lbX%.*s", name->len,name->s); profile_name.s = buf; /* first check if the profile already exists */ new_res->profile = lb_dlg_binds.search_profile( &profile_name ); if (new_res->profile==NULL) { /* create a new one */ LM_DBG("adding dialog profile <%.*s>\n", profile_name.len,profile_name.s); if (lb_dlg_binds.add_profiles( buf, 1 /*has value*/ )!=0) { LM_ERR("failed to add dialog profile <%s>\n",buf); goto error; } new_res->profile = lb_dlg_binds.search_profile( &profile_name ); if (new_res->profile==NULL) { LM_CRIT("bug - cannot find just added profile\n"); goto error; } } else { LM_DBG("dialog profile <%.*s> found created\n", profile_name.len,profile_name.s); } /* keep the list alphabetical ordered */ p_res = NULL; res = data->resources; while (res) { o = (name->len < res->name.len)? strncmp(name->s, res->name.s, name->len): strncmp(name->s, res->name.s, res->name.len); if (o>0) /* add between p_res and res */ break; p_res = res; res = res->next; } if (p_res==NULL) { /* add at the beginning */ new_res->next = data->resources; data->resources = new_res; LM_DBG("adding <%.*s> as head\n",name->len,name->s); } else if (res==NULL) { /* add at the end */ p_res->next = new_res; LM_DBG("adding <%.*s> after <%.*s>\n", name->len,name->s,p_res->name.len,p_res->name.s); } else { /* add in the middle */ new_res->next = res; p_res->next = new_res; LM_DBG("adding <%.*s> after <%.*s>\n", name->len,name->s,p_res->name.len,p_res->name.s); } data->res_no ++; return new_res; error: if (new_res->lock) { lock_destroy( new_res->lock ); lock_dealloc( new_res->lock ); new_res->lock = 0; } shm_free(new_res); return NULL; }
int main (int argc, char **argv) { enum { PASS, SPLASH, TTY } which; Widget toplevel_shell = 0; saver_screen_info ssip; saver_info sip; saver_info *si = &sip; saver_preferences *p = &si->prefs; struct passwd *pw; memset(&sip, 0, sizeof(sip)); memset(&ssip, 0, sizeof(ssip)); si->nscreens = 1; si->screens = si->default_screen = &ssip; ssip.global = si; global_si_kludge = si; real_stderr = stderr; real_stdout = stdout; si->version = (char *) malloc (5); memcpy (si->version, screensaver_id + 17, 4); progname = argv[0]; { char *s = strrchr(progname, '/'); if (*s) strcpy (progname, s+1); } if (argc != 2) goto USAGE; else if (!strcmp (argv[1], "pass")) which = PASS; else if (!strcmp (argv[1], "splash")) which = SPLASH; else if (!strcmp (argv[1], "tty")) which = TTY; else { USAGE: fprintf (stderr, "usage: %s [ pass | splash | tty ]\n", progname); exit (1); } #ifdef NO_LOCKING if (which == PASS || which == TTY) { fprintf (stderr, "%s: compiled with NO_LOCKING\n", progname); exit (1); } #endif #ifndef NO_LOCKING /* before hack_uid() for proper permissions */ lock_priv_init (argc, argv, True); hack_uid (si); if (! lock_init (argc, argv, True)) { si->locking_disabled_p = True; si->nolock_reason = "error getting password"; } #endif progclass = "XScreenSaver"; if (which != TTY) { toplevel_shell = XtAppInitialize (&si->app, progclass, 0, 0, &argc, argv, fallback, 0, 0); si->dpy = XtDisplay (toplevel_shell); p->db = XtDatabase (si->dpy); si->default_screen->toplevel_shell = toplevel_shell; si->default_screen->screen = XtScreen(toplevel_shell); si->default_screen->default_visual = si->default_screen->current_visual = DefaultVisualOfScreen(si->default_screen->screen); si->default_screen->screensaver_window = RootWindowOfScreen(si->default_screen->screen); si->default_screen->current_depth = visual_depth(si->default_screen->screen, si->default_screen->current_visual); ssip.width = WidthOfScreen(ssip.screen); ssip.height = HeightOfScreen(ssip.screen); db = p->db; XtGetApplicationNameAndClass (si->dpy, &progname, &progclass); load_init_file (si->dpy, &si->prefs); } p->verbose_p = True; pw = getpwuid (getuid ()); si->user = strdup (pw->pw_name); /* si->nscreens = 0; si->screens = si->default_screen = 0; */ while (1) { #ifndef NO_LOCKING if (which == PASS) { si->unlock_cb = gui_auth_conv; si->auth_finished_cb = auth_finished_cb; xss_authenticate(si, True); if (si->unlock_state == ul_success) fprintf (stderr, "%s: authentication succeeded\n", progname); else fprintf (stderr, "%s: authentication FAILED!\n", progname); XSync(si->dpy, False); fprintf (stderr, "\n######################################\n\n"); sleep (3); } else #endif if (which == SPLASH) { XEvent event; make_splash_dialog (si); XtAppAddTimeOut (si->app, p->splash_duration + 1000, idle_timer, (XtPointer) si); while (si->splash_dialog) { XtAppNextEvent (si->app, &event); if (event.xany.window == si->splash_dialog) handle_splash_event (si, &event); XtDispatchEvent (&event); } XSync (si->dpy, False); sleep (1); } #ifndef NO_LOCKING else if (which == TTY) { si->unlock_cb = text_auth_conv; printf ("%s: Authenticating user %s\n", progname, si->user); xss_authenticate(si, True); if (si->unlock_state == ul_success) printf ("%s: Ok!\n", progname); else printf ("%s: Wrong!\n", progname); } #endif else abort(); } free(si->user); }
/*! * \brief Create a new contact structure * \param _dom domain * \param _aor address of record * \param _contact contact string * \param _ci contact informations * \return new created contact on success, 0 on failure */ ucontact_t* new_ucontact(str* _dom, str* _aor, str* _contact, ucontact_info_t* _ci) { ucontact_t *c; param_t *prev, *curr, *param; int first = 1; c = (ucontact_t*) shm_malloc(sizeof (ucontact_t)); if (!c) { LM_ERR("no more shm memory\n"); return 0; } memset(c, 0, sizeof (ucontact_t)); c->lock = lock_alloc(); c->lock = lock_init(c->lock); //setup callback list c->cbs = (struct ulcb_head_list*) shm_malloc(sizeof (struct ulcb_head_list)); if (c->cbs == 0) { LM_CRIT("no more shared mem\n"); goto error; } c->cbs->first = 0; c->cbs->reg_types = 0; /*Copy parameter list into shm**/ param = _ci->params; while(param) { /*Copy first param in curr*/ curr = shm_malloc(sizeof (param_t)); curr->len = param->len; curr->type = param->type; curr->next = 0; if (shm_str_dup(&curr->body, ¶m->body) < 0) goto error; if (shm_str_dup(&curr->name, ¶m->name) < 0) goto error; if(first) { c->params = curr; first = 0; } else { prev->next = curr; } prev = curr; param = param->next; } if (shm_str_dup(&c->c, _contact) < 0) goto error; if (shm_str_dup(&c->callid, _ci->callid) < 0) goto error; if (shm_str_dup(&c->user_agent, _ci->user_agent) < 0) goto error; if (shm_str_dup(&c->aor, _aor) < 0) goto error; if (shm_str_dup(&c->domain, _dom) < 0) goto error; if (_ci->received.s && _ci->received.len) { if (shm_str_dup(&c->received, &_ci->received) < 0) goto error; } if (_ci->path && _ci->path->len) { if (shm_str_dup(&c->path, _ci->path) < 0) goto error; } LM_DBG("generating hash based on [%.*s]\n", _contact->len, _contact->s); c->contact_hash = core_hash(_contact, 0, contact_list->size); c->ref_count = 1; c->expires = _ci->expires; c->q = _ci->q; c->sock = _ci->sock; c->cseq = _ci->cseq; c->flags = _ci->flags; c->cflags = _ci->cflags; c->methods = _ci->methods; c->last_modified = _ci->last_modified; return c; error: LM_ERR("no more shm memory\n"); if (c->path.s) shm_free(c->path.s); if (c->received.s) shm_free(c->received.s); if (c->user_agent.s) shm_free(c->user_agent.s); if (c->callid.s) shm_free(c->callid.s); if (c->c.s) shm_free(c->c.s); if (c->domain.s) shm_free(c->domain.s); if (c->aor.s) shm_free(c->aor.s); shm_free(c); return 0; }
/** * Init the in-memory registration database in hash table */ int uac_reg_init_ht(unsigned int sz) { int i; _reg_htable_gc_lock = (gen_lock_t*)shm_malloc(sizeof(gen_lock_t)); if(_reg_htable_gc_lock == NULL) { LM_ERR("no more shm for lock\n"); return -1; } if(lock_init(_reg_htable_gc_lock)==0) { LM_ERR("cannot init global lock\n"); shm_free((void*)_reg_htable_gc_lock); return -1; } _reg_htable_gc = (reg_ht_t*)shm_malloc(sizeof(reg_ht_t)); if(_reg_htable_gc==NULL) { LM_ERR("no more shm\n"); lock_destroy(_reg_htable_gc_lock); shm_free((void*)_reg_htable_gc_lock); return -1; } memset(_reg_htable_gc, 0, sizeof(reg_ht_t)); _reg_htable_gc->htsize = sz; _reg_htable_gc->entries = (reg_entry_t*)shm_malloc(_reg_htable_gc->htsize*sizeof(reg_entry_t)); if(_reg_htable_gc->entries==NULL) { LM_ERR("no more shm.\n"); shm_free(_reg_htable_gc); lock_destroy(_reg_htable_gc_lock); shm_free((void*)_reg_htable_gc_lock); return -1; } memset(_reg_htable_gc->entries, 0, _reg_htable_gc->htsize*sizeof(reg_entry_t)); _reg_htable = (reg_ht_t*)shm_malloc(sizeof(reg_ht_t)); if(_reg_htable==NULL) { LM_ERR("no more shm\n"); shm_free(_reg_htable_gc->entries); shm_free(_reg_htable_gc); lock_destroy(_reg_htable_gc_lock); shm_free((void*)_reg_htable_gc_lock); return -1; } memset(_reg_htable, 0, sizeof(reg_ht_t)); _reg_htable->htsize = sz; _reg_htable->entries = (reg_entry_t*)shm_malloc(_reg_htable->htsize*sizeof(reg_entry_t)); if(_reg_htable->entries==NULL) { LM_ERR("no more shm.\n"); shm_free(_reg_htable_gc->entries); shm_free(_reg_htable_gc); shm_free(_reg_htable); lock_destroy(_reg_htable_gc_lock); shm_free((void*)_reg_htable_gc_lock); return -1; } memset(_reg_htable->entries, 0, _reg_htable->htsize*sizeof(reg_entry_t)); for(i=0; i<_reg_htable->htsize; i++) { if(lock_init(&_reg_htable->entries[i].lock)==0) { LM_ERR("cannot initialize lock[%d] n", i); i--; while(i>=0) { lock_destroy(&_reg_htable->entries[i].lock); i--; } shm_free(_reg_htable->entries); shm_free(_reg_htable); shm_free(_reg_htable_gc->entries); shm_free(_reg_htable_gc); lock_destroy(_reg_htable_gc_lock); shm_free((void*)_reg_htable_gc_lock); return -1; } } /* Initialize uac reg counters */ uac_reg_counter_init(); return 0; }
int main(int argc, char** argv) { ATOMIC_TYPE var; VALUE_TYPE r; ATOMIC_TYPE* v; v=&var; #ifdef MEMBAR_USES_LOCK __membar_lock=&dummy_membar_lock; if (lock_init(__membar_lock)==0){ fprintf(stderr, "ERROR: failed to initialize membar_lock\n"); __membar_lock=0; goto error; } _membar_lock; /* start with the lock "taken" so that we can safely use unlock/lock sequences on it later */ #endif #ifdef ATOMIC_OPS_USE_LOCK /* init the lock (emulate atomic_ops.c) */ _atomic_lock=&dummy_atomic_lock; if (lock_init(_atomic_lock)==0){ fprintf(stderr, "ERROR: failed to initialize atomic_lock\n"); _atomic_lock=0; goto error; } #endif printf("%s\n", flags); printf("starting memory barrier opcode tests...\n"); membar(); printf(" membar() .............................. ok\n"); membar_write(); printf(" membar_write() ........................ ok\n"); membar_read(); printf(" membar_read() ......................... ok\n"); printf("\nstarting atomic ops basic tests...\n"); VERIFY(at_set(v, 1), 1); printf(" atomic_set, v should be 1 ............. %2d\n", (int)at_get(v)); VERIFY(at_inc(v), 2); printf(" atomic_inc, v should be 2 ............. %2d\n", (int)at_get(v)); VERIFY(r=at_inc_and_test(v), 3); printf(" atomic_inc_and_test, v should be 3 ... %2d\n", (int)at_get(v)); printf(" r should be 0 ... %2d\n", (int)r); VERIFY(at_dec(v), 2); printf(" atomic_dec, v should be 2 ............. %2d\n", (int)at_get(v)); VERIFY(r=at_dec_and_test(v), 1); printf(" atomic_dec_and_test, v should be 1 ... %2d\n", (int)at_get(v)); printf(" r should be 0 ... %2d\n", (int)r); VERIFY(r=at_dec_and_test(v), 0); printf(" atomic_dec_and_test, v should be 0 ... %2d\n", (int)at_get(v)); printf(" r should be 1 ... %2d\n", (int)r); VERIFY(r=at_dec_and_test(v), -1); printf(" atomic_dec_and_test, v should be -1 ... %2d\n", (int)at_get(v)); printf(" r should be 0 ... %2d\n", (int)r); VERIFY(at_and(v, 2), 2); printf(" atomic_and, v should be 2 ............. %2d\n", (int)at_get(v)); VERIFY(at_or(v, 5), 7); VERIFY(r=at_get_and_set(v, 0), 0); printf(" atomic_or, v should be 7 ............. %2d\n", (int)r); printf(" atomic_get_and_set, v should be 0 ..... %2d\n", (int)at_get(v)); printf("\ndone.\n"); #ifdef MEMBAR_USES_LOCK lock_destroy(__membar_lock); #endif #ifdef ATOMIC_OPS_USE_LOCK lock_destroy(_atomic_lock); #endif return 0; error: #ifdef MEMBAR_USES_LOCK if (__membar_lock) lock_destroy(__membar_lock); #endif #ifdef ATOMIC_OPS_USE_LOCK if (_atomic_lock) lock_destroy(_atomic_lock); #endif return -1; }
/*! \brief * Init module function */ static int mod_init(void) { if(register_mi_mod(exports.name, mi_cmds)!=0) { LM_ERR("failed to register MI commands\n"); return -1; } /* Group matching feature */ if (file == NULL) { LM_NOTICE("'file' parameter is not set, group matching disabled\n"); } else { /* Create and init the lock */ reload_lock = lock_alloc(); if (reload_lock == NULL) { LM_ERR("cannot allocate reload_lock\n"); goto err; } if (lock_init(reload_lock) == NULL) { LM_ERR("cannot init the reload_lock\n"); lock_dealloc(reload_lock); goto err; } /* PCRE options */ if (pcre_caseless != 0) { LM_DBG("PCRE CASELESS enabled\n"); pcre_options = pcre_options | PCRE_CASELESS; } if (pcre_multiline != 0) { LM_DBG("PCRE MULTILINE enabled\n"); pcre_options = pcre_options | PCRE_MULTILINE; } if (pcre_dotall != 0) { LM_DBG("PCRE DOTALL enabled\n"); pcre_options = pcre_options | PCRE_DOTALL; } if (pcre_extended != 0) { LM_DBG("PCRE EXTENDED enabled\n"); pcre_options = pcre_options | PCRE_EXTENDED; } LM_DBG("PCRE options: %i\n", pcre_options); /* Pointer to pcres */ if ((pcres_addr = shm_malloc(sizeof(pcre **))) == 0) { LM_ERR("no memory for pcres_addr\n"); goto err; } /* Integer containing the number of pcres */ if ((num_pcres = shm_malloc(sizeof(int))) == 0) { LM_ERR("no memory for num_pcres\n"); goto err; } /* Load the pcres */ LM_DBG("loading pcres...\n"); if (load_pcres(START)) { LM_ERR("failed to load pcres\n"); goto err; } } return 0; err: free_shared_memory(); return -1; }
static int icscf_mod_init(void) { load_tm_f load_tm; load_cdp_f load_cdp; LOG(L_INFO,"INFO:"M_NAME":mod_init: Initialization of module\n"); /* fix the parameters */ if (!fix_parameters()) goto error; #ifdef WITH_IMS_PM ims_pm_init(icscf_name_str,ims_pm_node_type, ims_pm_logfile); ims_pm_init_icscf(); #endif /* WITH_IMS_PM */ cscf_icid_value_count = shm_malloc(sizeof(unsigned int)); *cscf_icid_value_count = 0; cscf_icid_value_count_lock = lock_alloc(); cscf_icid_value_count_lock = lock_init(cscf_icid_value_count_lock); /* load the send_reply function from sl module */ sl_reply = find_export("sl_send_reply", 2, 0); if (!sl_reply) { LOG(L_ERR, "ERR"M_NAME":mod_init: This module requires sl module\n"); goto error; } /* bind to the tm module */ if (!(load_tm = (load_tm_f)find_export("load_tm",NO_SCRIPT,0))) { LOG(L_ERR, "ERR"M_NAME":mod_init: Can not import load_tm. This module requires tm module\n"); goto error; } if (load_tm(&tmb) == -1) goto error; /* bind to the cdp module */ if (!(load_cdp = (load_cdp_f)find_export("load_cdp",NO_SCRIPT,0))) { LOG(L_ERR, "ERR"M_NAME":mod_init: Can not import load_cdp. This module requires cdp module\n"); goto error; } if (load_cdp(&cdpb) == -1) goto error; /* cache the trusted domain names and capabilities */ /* bind to the db module */ if ( icscf_db_bind( icscf_db_url ) < 0 ) goto error; icscf_db_init( icscf_db_url, icscf_db_nds_table, icscf_db_scscf_table, icscf_db_capabilities_table); I_NDS_get_trusted_domains(); I_get_capabilities(); icscf_db_close(); if (!i_hash_table_init(icscf_hash_size)){ LOG(L_ERR, "ERR"M_NAME":mod_init: Error initializing the Hash Table for stored S-CSCF lists\n"); goto error; } // //TODO - only for S-CSCF - I-CSCF does not respond to request //// AAAAddRequestHandler(&CxRequestHandler,0); // /* don't register response callback as we always set callback per transactions // * and we're not interested in other responses */ // /*AAAAddResponseHandler(&CxAnswerHandler,0);*/ // /** initialize twofish variables and tables (THIG)**/ srand((unsigned) time(NULL)); thig_key_and_cipher_init(&ki,&ci); LOG(L_INFO,"Twofish encryption ready\n"); int route_no; /* try to fix the icscf_route_on_term_user_unknown route */ if (icscf_route_on_term_user_unknown){ route_no=route_get(&main_rt, icscf_route_on_term_user_unknown); if (route_no==-1){ LOG(L_ERR, "ERR"M_NAME":mod_init: failed to fix route \"%s\": route_get() failed\n", icscf_route_on_term_user_unknown); return -1; } if (main_rt.rlist[route_no]==0){ LOG(L_ERR, "ERR"M_NAME":mod_init: icscf_route_on_term_user_unknown \"%s\" is empty / doesn't exist\n", icscf_route_on_term_user_unknown); } route_on_term_user_unknown_n=route_no; } return 0; error: return -1; }
/* initialize ratelimit module */ static int mod_init(void) { int i; if (rpc_register_array(rpc_methods)!=0) { LM_ERR("failed to register RPC commands\n"); return -1; } rl_lock = lock_alloc(); if (! rl_lock) { LM_ERR("oom in lock_alloc()\n"); return -1; } if (lock_init(rl_lock)==0) { LM_ERR("failed to init lock\n"); return -1; } /* register timer to reset counters */ if ((rl_timer = timer_alloc()) == NULL) { LM_ERR("could not allocate timer\n"); return -1; } timer_init(rl_timer, rl_timer_handle, 0, F_TIMER_FAST); timer_add(rl_timer, MS_TO_TICKS(1000*timer_interval)); network_load_value = shm_malloc(sizeof(int)); if (network_load_value==NULL) { LM_ERR("oom for network_load_value\n"); return -1; } load_value = shm_malloc(sizeof(double)); if (load_value==NULL) { LM_ERR("oom for load_value\n"); return -1; } load_source = shm_malloc(sizeof(int)); if (load_source==NULL) { LM_ERR("oom for load_source\n"); return -1; } pid_kp = shm_malloc(sizeof(double)); if (pid_kp==NULL) { LM_ERR("oom for pid_kp\n"); return -1; } pid_ki = shm_malloc(sizeof(double)); if (pid_ki==NULL) { LM_ERR("oom for pid_ki\n"); return -1; } pid_kd = shm_malloc(sizeof(double)); if (pid_kd==NULL) { LM_ERR("oom for pid_kd\n"); return -1; } pid_setpoint = shm_malloc(sizeof(double)); if (pid_setpoint==NULL) { LM_ERR("oom for pid_setpoint\n"); return -1; } drop_rate = shm_malloc(sizeof(int)); if (drop_rate==NULL) { LM_ERR("oom for drop_rate\n"); return -1; } nqueues = shm_malloc(sizeof(int)); if (nqueues==NULL) { LM_ERR("oom for nqueues\n"); return -1; } rl_dbg_str = shm_malloc(sizeof(str)); if (rl_dbg_str==NULL) { LM_ERR("oom for rl_dbg_str\n"); return -1; } *network_load_value = 0; *load_value = 0.0; *load_source = load_source_mp; *pid_kp = 0.0; *pid_ki = -25.0; *pid_kd = 0.0; *pid_setpoint = 0.01 * (double)cfg_setpoint; *drop_rate = 0; *nqueues = nqueues_mp; rl_dbg_str->s = NULL; rl_dbg_str->len = 0; for (i=0; i<MAX_PIPES; i++) { pipes[i].algo = shm_malloc(sizeof(int)); if (pipes[i].algo==NULL) { LM_ERR("oom for pipes[%d].algo\n", i); return -1; } pipes[i].limit = shm_malloc(sizeof(int)); if (pipes[i].limit==NULL) { LM_ERR("oom for pipes[%d].limit\n", i); return -1; } pipes[i].load = shm_malloc(sizeof(int)); if (pipes[i].load==NULL) { LM_ERR("oom for pipes[%d].load\n", i); return -1; } pipes[i].counter = shm_malloc(sizeof(int)); if (pipes[i].counter==NULL) { LM_ERR("oom for pipes[%d].counter\n", i); return -1; } pipes[i].last_counter = shm_malloc(sizeof(int)); if (pipes[i].last_counter==NULL) { LM_ERR("oom for pipes[%d].last_counter\n", i); return -1; } *pipes[i].algo = pipes[i].algo_mp; *pipes[i].limit = pipes[i].limit_mp; *pipes[i].load = 0; *pipes[i].counter = 0; *pipes[i].last_counter = 0; } for (i=0; i<*nqueues; i++) { queues[i].pipe = shm_malloc(sizeof(int)); if (queues[i].pipe==NULL) { LM_ERR("oom for queues[%d].pipe\n", i); return -1; } queues[i].method = shm_malloc(sizeof(str)); if (queues[i].method==NULL) { LM_ERR("oom for queues[%d].method\n", i); return -1; } *queues[i].pipe = queues[i].pipe_mp; if (queues[i].method_mp.s == NULL) { LM_ERR("unexpected NULL method for queues[%d].method_mp\n", i); return -1; } if(str_cpy(queues[i].method, &queues[i].method_mp)) { LM_ERR("oom str_cpy(queues[%d].method\n", i); return -1; } pkg_free(queues[i].method_mp.s); queues[i].method_mp.s = NULL; queues[i].method_mp.len = 0; } return 0; }
static int mod_init(void) { int method; if (tls_disable){ LOG(L_WARN, "tls support is disabled " "(set enable_tls=1 in the config to enable it)\n"); return 0; } if (fix_tls_cfg(&default_tls_cfg) < 0 ) { ERR("initial tls configuration fixup failed\n"); return -1; } /* declare configuration */ if (cfg_declare("tls", tls_cfg_def, &default_tls_cfg, cfg_sizeof(tls), (void **)&tls_cfg)) { ERR("failed to register the configuration\n"); return -1; } /* Convert tls_method parameter to integer */ method = tls_parse_method(&cfg_get(tls, tls_cfg, method)); if (method < 0) { ERR("Invalid tls_method parameter value\n"); return -1; } /* fill mod_params */ mod_params.method = method; mod_params.verify_cert = cfg_get(tls, tls_cfg, verify_cert); mod_params.verify_depth = cfg_get(tls, tls_cfg, verify_depth); mod_params.require_cert = cfg_get(tls, tls_cfg, require_cert); mod_params.pkey_file = cfg_get(tls, tls_cfg, private_key); mod_params.ca_file = cfg_get(tls, tls_cfg, ca_list); mod_params.crl_file = cfg_get(tls, tls_cfg, crl); mod_params.cert_file = cfg_get(tls, tls_cfg, certificate); mod_params.cipher_list = cfg_get(tls, tls_cfg, cipher_list); mod_params.server_name = cfg_get(tls, tls_cfg, server_name); tls_domains_cfg = (tls_domains_cfg_t**)shm_malloc(sizeof(tls_domains_cfg_t*)); if (!tls_domains_cfg) { ERR("Not enough shared memory left\n"); goto error; } *tls_domains_cfg = NULL; register_select_table(tls_sel); /* register the rpc interface */ if (rpc_register_array(tls_rpc)!=0) { LOG(L_ERR, "failed to register RPC commands\n"); goto error; } /* if (init_tls() < 0) return -1; */ tls_domains_cfg_lock = lock_alloc(); if (tls_domains_cfg_lock == 0) { ERR("Unable to create TLS configuration lock\n"); goto error; } if (lock_init(tls_domains_cfg_lock) == 0) { lock_dealloc(tls_domains_cfg_lock); ERR("Unable to initialize TLS configuration lock\n"); goto error; } if (tls_ct_wq_init() < 0) { ERR("Unable to initialize TLS buffering\n"); goto error; } if (cfg_get(tls, tls_cfg, config_file).s) { *tls_domains_cfg = tls_load_config(&cfg_get(tls, tls_cfg, config_file)); if (!(*tls_domains_cfg)) goto error; } else { *tls_domains_cfg = tls_new_cfg(); if (!(*tls_domains_cfg)) goto error; } if (tls_check_sockets(*tls_domains_cfg) < 0) goto error; #ifndef OPENSSL_NO_ECDH LM_INFO("With ECDH-Support!\n"); #endif #ifndef OPENSSL_NO_DH LM_INFO("With Diffie Hellman\n"); #endif tls_lookup_event_routes(); return 0; error: destroy_tls_h(); return -1; }
int mq_head_add(str *name, int msize) { mq_head_t *mh = NULL; mq_pv_t *mp = NULL; int len; if(!shm_initialized()) { LM_ERR("shm not intialized - cannot define mqueue now\n"); return 0; } mh = _mq_head_list; while(mh!=NULL) { if(name->len == mh->name.len && strncmp(mh->name.s, name->s, name->len)==0) { LM_ERR("mqueue redefined: %.*s\n", name->len, name->s); return -1; } mh = mh->next; } mp = (mq_pv_t*)pkg_malloc(sizeof(mq_pv_t)); if(mp==NULL) { LM_ERR("no more pkg for: %.*s\n", name->len, name->s); return -1; } memset(mp, 0, sizeof(mq_pv_t)); len = sizeof(mq_head_t) + name->len + 1; mh = (mq_head_t*)shm_malloc(len); if(mh==NULL) { LM_ERR("no more shm for: %.*s\n", name->len, name->s); pkg_free(mp); return -1; } memset(mh, 0, len); if (lock_init(&mh->lock)==0 ) { LM_CRIT("failed to init lock\n"); pkg_free(mp); shm_free(mh); return -1; } mh->name.s = (char*)mh + sizeof(mq_head_t); memcpy(mh->name.s, name->s, name->len); mh->name.len = name->len; mh->name.s[name->len] = '\0'; mh->msize = msize; mh->next = _mq_head_list; _mq_head_list = mh; mp->name = &mh->name; mp->next = _mq_pv_list; _mq_pv_list = mp; return 0; }
/* Initialize the system call parts */ void syscall_init (void) { intr_register_int (0x30, 3, INTR_ON, syscall_handler, "syscall"); lock_init (&fs_lock); }
static int _bm_register_timer(char *tname, int mode, unsigned int *id) { benchmark_timer_t *bmt = 0; benchmark_timer_t **tidx = 0; if(tname==NULL || id==NULL || bm_mycfg==NULL || strlen(tname)==0 || strlen(tname)>BM_NAME_LEN-1) return -1; bmt = bm_mycfg->timers; while(bmt) { if(strcmp(bmt->name, tname)==0) { *id = bmt->id; return 0; } bmt = bmt->next; } if(mode==0) return -1; bmt = (benchmark_timer_t*)shm_malloc(sizeof(benchmark_timer_t)); if(bmt==0) { LM_ERR("no more shm\n"); return -1; } memset(bmt, 0, sizeof(benchmark_timer_t)); bmt->lock = lock_alloc(); if(bmt->lock == NULL) { shm_free(bmt); LM_ERR("no more shm\n"); return -1; } if (!lock_init(bmt->lock)) { lock_dealloc(bmt->lock); shm_free(bmt); LM_ERR("failed to init lock\n"); return -1; } /* private memory, otherwise we have races */ bmt->start = (bm_timeval_t*)pkg_malloc(sizeof(bm_timeval_t)); if(bmt->start == NULL) { lock_dealloc(bmt->lock); shm_free(bmt); LM_ERR("no more pkg\n"); return -1; } memset(bmt->start, 0, sizeof(bm_timeval_t)); strcpy(bmt->name, tname); if(bm_mycfg->timers==0) { bmt->id = 0; bm_mycfg->timers = bmt; } else { bmt->id = bm_mycfg->timers->id+1; bmt->next = bm_mycfg->timers; bm_mycfg->timers = bmt; } /* do the indexing */ if(bmt->id%10==0) { if(bm_mycfg->tindex!=NULL) tidx = bm_mycfg->tindex; bm_mycfg->tindex = (benchmark_timer_t**)shm_malloc((10+bmt->id)* sizeof(benchmark_timer_t*)); if(bm_mycfg->tindex==0) { LM_ERR("no more share memory\n"); if(tidx!=0) shm_free(tidx); return -1; } memset(bm_mycfg->tindex, 0, (10+bmt->id)*sizeof(benchmark_timer_t*)); if(tidx!=0) { memcpy(bm_mycfg->tindex, tidx, bmt->id*sizeof(benchmark_timer_t*)); shm_free(tidx); } } bm_mycfg->tindex[bmt->id] = bmt; bm_mycfg->nrtimers = bmt->id + 1; reset_timer(bmt->id); *id = bmt->id; LM_DBG("timer [%s] added with index <%u>\n", bmt->name, bmt->id); return 0; }
/*! * \brief Initialize the global dialog table * \param size size of the table * \return 0 on success, -1 on failure */ int init_dlg_table(unsigned int size) { unsigned int n; unsigned int i; dlg_ka_list_head = (dlg_ka_t **)shm_malloc(sizeof(dlg_ka_t *)); if(dlg_ka_list_head==NULL) { LM_ERR("no more shm mem (h)\n"); goto error0; } dlg_ka_list_tail = (dlg_ka_t **)shm_malloc(sizeof(dlg_ka_t *)); if(dlg_ka_list_tail==NULL) { LM_ERR("no more shm mem (t)\n"); goto error0; } *dlg_ka_list_head = NULL; *dlg_ka_list_tail = NULL; dlg_ka_list_lock = (gen_lock_t*)shm_malloc(sizeof(gen_lock_t)); if(dlg_ka_list_lock==NULL) { LM_ERR("no more shm mem (l)\n"); goto error0; } lock_init(dlg_ka_list_lock); d_table = (struct dlg_table*)shm_malloc ( sizeof(struct dlg_table) + size*sizeof(struct dlg_entry)); if (d_table==0) { LM_ERR("no more shm mem (1)\n"); goto error0; } memset( d_table, 0, sizeof(struct dlg_table) ); d_table->size = size; d_table->entries = (struct dlg_entry*)(d_table+1); n = (size<MAX_LDG_LOCKS)?size:MAX_LDG_LOCKS; for( ; n>=MIN_LDG_LOCKS ; n-- ) { d_table->locks = lock_set_alloc(n); if (d_table->locks==0) continue; if (lock_set_init(d_table->locks)==0) { lock_set_dealloc(d_table->locks); d_table->locks = 0; continue; } d_table->locks_no = n; break; } if (d_table->locks==0) { LM_ERR("unable to allocted at least %d locks for the hash table\n", MIN_LDG_LOCKS); goto error1; } for( i=0 ; i<size; i++ ) { memset( &(d_table->entries[i]), 0, sizeof(struct dlg_entry) ); d_table->entries[i].next_id = rand() % (3*size); d_table->entries[i].lock_idx = i % d_table->locks_no; } return 0; error1: shm_free( d_table ); d_table = NULL; error0: if(dlg_ka_list_head!=NULL) shm_free(dlg_ka_list_head); if(dlg_ka_list_tail!=NULL) shm_free(dlg_ka_list_tail); dlg_ka_list_head = NULL; dlg_ka_list_tail = NULL; return -1; }
/*! * \brief Creates a new dialog profile * \see add_profile_definitions * \param name profile name * \param size profile size * \param has_value set to 0 for a profile without value, otherwise it has a value * \return pointer to the created dialog on success, NULL otherwise */ static struct dlg_profile_table* new_dlg_profile( str *name, unsigned int size, unsigned int has_value) { struct dlg_profile_table *profile; struct dlg_profile_table *ptmp; unsigned int len; unsigned int i; if ( name->s==NULL || name->len==0 || size==0 ) { LM_ERR("invalid parameters\n"); return NULL; } for( len=0,i=0 ; i<8*sizeof(size) ; i++ ) { if ( size & (1<<i) ) len++; } if (len!=1) { LM_ERR(" size %u is not power of 2!\n", size); return NULL; } profile = search_dlg_profile(name); if (profile!=NULL) { LM_ERR("duplicate dialog profile registered <%.*s>\n", name->len, name->s); return NULL; } len = sizeof(struct dlg_profile_table) + size*sizeof(struct dlg_profile_entry) + name->len + 1; profile = (struct dlg_profile_table *)shm_malloc(len); if (profile==NULL) { LM_ERR("no more shm mem\n"); return NULL; } memset( profile , 0 , len); profile->size = size; profile->has_value = (has_value==0)?0:1; /* init lock */ if (lock_init( &profile->lock )==NULL) { LM_ERR("failed to init lock\n"); shm_free(profile); return NULL; } /* set inner pointers */ profile->entries = (struct dlg_profile_entry*)(profile + 1); profile->name.s = ((char*)profile->entries) + size*sizeof(struct dlg_profile_entry); /* copy the name of the profile */ memcpy( profile->name.s, name->s, name->len ); profile->name.len = name->len; profile->name.s[profile->name.len] = 0; /* link profile */ for( ptmp=profiles ; ptmp && ptmp->next; ptmp=ptmp->next ); if (ptmp==NULL) { profiles = profile; sruid_init(&_dlg_profile_sruid, '-', "dlgp", SRUID_INC); } else { ptmp->next = profile; } return profile; }
/* Initialize mmap */ void mmap_init (void) { struct thread *t = thread_current (); lock_init (&t->mmap_lock); hash_init (&t->mmap_table, mmap_hash, mmap_less, NULL); }
void sem_init(struct Semaphore *s) { s->count = 0; lock_init(&s->lock); init_q(&s->q); }
int shm_getmem() { #ifdef SHM_MMAP int fd; #else struct shmid_ds shm_info; #endif #ifdef SHM_MMAP if (shm_mempool && (shm_mempool!=(void*)-1)){ #else if ((shm_shmid!=-1)||(shm_mempool!=(void*)-1)){ #endif LOG(L_CRIT, "BUG: shm_mem_init: shm already initialized\n"); return -1; } #ifdef SHM_MMAP fd=open("/dev/zero", O_RDWR); if (fd==-1){ LOG(L_CRIT, "ERROR: shm_mem_init: could not open /dev/zero: %s\n", strerror(errno)); return -1; } shm_mempool=mmap(0, shm_mem_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd ,0); /* close /dev/zero */ close(fd); #else shm_shmid=shmget(IPC_PRIVATE, /* SHM_MEM_SIZE */ shm_mem_size , 0700); if (shm_shmid==-1){ LOG(L_CRIT, "ERROR: shm_mem_init: could not allocate shared memory" " segment: %s\n", strerror(errno)); return -1; } shm_mempool=shmat(shm_shmid, 0, 0); #endif if (shm_mempool==(void*)-1){ LOG(L_CRIT, "ERROR: shm_mem_init: could not attach shared memory" " segment: %s\n", strerror(errno)); /* destroy segment*/ shm_mem_destroy(); return -1; } return 0; } int shm_mem_init_mallocs(void* mempool, int pool_size) { /* init it for malloc*/ shm_block=shm_malloc_init(mempool, pool_size); if (shm_block==0){ LOG(L_CRIT, "ERROR: shm_mem_init: could not initialize shared" " malloc\n"); shm_mem_destroy(); return -1; } mem_lock=shm_malloc_unsafe(sizeof(gen_lock_t)); /* skip lock_alloc, race cond*/ if (mem_lock==0){ LOG(L_CRIT, "ERROR: shm_mem_init: could not allocate lock\n"); shm_mem_destroy(); return -1; } if (lock_init(mem_lock)==0){ LOG(L_CRIT, "ERROR: shm_mem_init: could not initialize lock\n"); shm_mem_destroy(); return -1; } DBG("shm_mem_init: success\n"); return 0; }
static int mod_init(void) { str stmp; LM_INFO("initializing...\n"); /* load SIGNALING API */ if(load_sig_api(&sigb)< 0){ LM_ERR("can't load signaling functions\n"); return -1; } /* If the parameter was not used */ if (sec_param == 0) { /* Generate secret using random generator */ if (generate_random_secret() < 0) { LM_ERR("failed to generate random secret\n"); return -3; } } else { /* Otherwise use the parameter's value */ secret.s = sec_param; secret.len = strlen(secret.s); } if ( init_rpid_avp(rpid_avp_param)<0 ) { LM_ERR("failed to process rpid AVPs\n"); return -4; } rpid_prefix.len = strlen(rpid_prefix.s); rpid_suffix.len = strlen(rpid_suffix.s); realm_prefix.len = strlen(realm_prefix.s); if(user_spec_param!=0) { stmp.s = user_spec_param; stmp.len = strlen(stmp.s); if(pv_parse_spec(&stmp, &user_spec)==NULL) { LM_ERR("failed to parse username spec\n"); return -5; } switch(user_spec.type) { case PVT_NONE: case PVT_EMPTY: case PVT_NULL: case PVT_MARKER: case PVT_COLOR: LM_ERR("invalid username spec\n"); return -6; default: ; } } if(passwd_spec_param!=0) { stmp.s = passwd_spec_param; stmp.len = strlen(stmp.s); if(pv_parse_spec(&stmp, &passwd_spec)==NULL) { LM_ERR("failed to parse password spec\n"); return -7; } switch(passwd_spec.type) { case PVT_NONE: case PVT_EMPTY: case PVT_NULL: case PVT_MARKER: case PVT_COLOR: LM_ERR("invalid password spec\n"); return -8; default: ; } } if(!disable_nonce_check) { nonce_lock = (gen_lock_t*)lock_alloc(); if(nonce_lock== NULL) { LM_ERR("no more shared memory\n"); return -1; } /* initialize lock_nonce */ if(lock_init(nonce_lock)== 0) { LM_ERR("failed to init lock\n"); return -9; } nonce_buf= (char*)shm_malloc(NBUF_LEN); if(nonce_buf== NULL) { LM_ERR("no more share memory\n"); return -10; } memset(nonce_buf, 255, NBUF_LEN); sec_monit= (int*)shm_malloc((nonce_expire +1)* sizeof(int)); if(sec_monit== NULL) { LM_ERR("no more share memory\n"); return -10; } memset(sec_monit, -1, (nonce_expire +1)* sizeof(int)); second= (int*)shm_malloc(sizeof(int)); next_index= (int*)shm_malloc(sizeof(int)); if(second== NULL || next_index== NULL) { LM_ERR("no more share memory\n"); return -10; } *next_index= -1; } return 0; }
void fmt_init (void) { hash_init(&frames_table, get_frame_hash, cmp_frame_hash, NULL); lock_init(&frame_table_lock); cond_init(&frame_table_cond); lock_init(&ht_exec_to_threads_lock); }
/* initialize the locks; return 0 on success, -1 otherwise */ int lock_initialize( unsigned int timer_sets ) { int i; #ifndef GEN_LOCK_T_PREFERED int probe_run; #endif /* first try allocating semaphore sets with fixed number of semaphores */ LM_DBG("lock initialization started\n"); timer_group_lock=shm_malloc(timer_sets*TG_NR*sizeof(ser_lock_t)); if (timer_group_lock==0){ LM_CRIT("no more share mem\n"); goto error; } #ifdef GEN_LOCK_T_PREFERED for(i=0;i<timer_sets*TG_NR;i++) lock_init(&timer_group_lock[i]); #else /* transaction timers */ if (((timer_semaphore= lock_set_alloc( TG_NR ) ) == 0)|| (lock_set_init(timer_semaphore)==0)){ if (timer_semaphore) lock_set_destroy(timer_semaphore); LM_CRIT("transaction timer semaphore initialization failure: %s\n", strerror(errno)); goto error; } for (i=0; i<TG_NR; i++) { timer_group_lock[i].semaphore_set = timer_semaphore; timer_group_lock[i].semaphore_index = timer_group[ i ]; } i=SEM_MIN; /* probing phase: 0=initial, 1=after the first failure */ probe_run=0; again: do { if (entry_semaphore!=0){ /* clean-up previous attempt */ lock_set_destroy(entry_semaphore); lock_set_dealloc(entry_semaphore); } if (reply_semaphore!=0){ lock_set_destroy(reply_semaphore); lock_set_dealloc(reply_semaphore); } if (i==0){ LM_CRIT("failed allocate semaphore sets\n"); goto error; } if (((entry_semaphore=lock_set_alloc(i))==0)|| (lock_set_init(entry_semaphore)==0)) { LM_DBG("entry semaphore initialization failure: %s\n", strerror( errno ) ); if (entry_semaphore){ lock_set_dealloc(entry_semaphore); entry_semaphore=0; } /* first time: step back and try again */ if (probe_run==0) { LM_DBG("first time semaphore allocation failure\n"); i--; probe_run=1; continue; /* failure after we stepped back; give up */ } else { LM_DBG("second time semaphore allocation failure\n"); goto error; } } /* allocation succeeded */ if (probe_run==1) { /* if ok after we stepped back, we're done */ break; } else { /* if ok otherwise, try again with larger set */ if (i==SEM_MAX) break; else { i++; continue; } } } while(1); sem_nr=i; if (((reply_semaphore=lock_set_alloc(i))==0)|| (lock_set_init(reply_semaphore)==0)){ if (reply_semaphore){ lock_set_dealloc(reply_semaphore); reply_semaphore=0; } LM_DBG("reply semaphore initialization failure: %s\n", strerror(errno)); probe_run=1; i--; goto again; } /* return success */ LM_INFO("semaphore arrays of size %d allocated\n", sem_nr ); #endif /* GEN_LOCK_T_PREFERED*/ return 0; error: lock_cleanup(); return -1; }
void syscall_init (void) { lock_init (&lock_filesys); intr_register_int (0x30, 3, INTR_ON, syscall_handler, "syscall"); }
/* initiate the cfg framework */ int cfg_init(void) { cfg_global_lock = lock_alloc(); if (!cfg_global_lock) { LOG(L_ERR, "ERROR: cfg_init(): not enough shm memory\n"); goto error; } if (lock_init(cfg_global_lock) == 0) { LOG(L_ERR, "ERROR: cfg_init(): failed to init lock\n"); lock_dealloc(cfg_global_lock); cfg_global_lock = 0; goto error; } cfg_writer_lock = lock_alloc(); if (!cfg_writer_lock) { LOG(L_ERR, "ERROR: cfg_init(): not enough shm memory\n"); goto error; } if (lock_init(cfg_writer_lock) == 0) { LOG(L_ERR, "ERROR: cfg_init(): failed to init lock\n"); lock_dealloc(cfg_writer_lock); cfg_writer_lock = 0; goto error; } cfg_global = (cfg_block_t **)shm_malloc(sizeof(cfg_block_t *)); if (!cfg_global) { LOG(L_ERR, "ERROR: cfg_init(): not enough shm memory\n"); goto error; } *cfg_global = NULL; cfg_child_cb_first = (cfg_child_cb_t **)shm_malloc(sizeof(cfg_child_cb_t *)); if (!cfg_child_cb_first) { LOG(L_ERR, "ERROR: cfg_init(): not enough shm memory\n"); goto error; } *cfg_child_cb_first = NULL; cfg_child_cb_last = (cfg_child_cb_t **)shm_malloc(sizeof(cfg_child_cb_t *)); if (!cfg_child_cb_last) { LOG(L_ERR, "ERROR: cfg_init(): not enough shm memory\n"); goto error; } *cfg_child_cb_last = NULL; /* A new cfg_child_cb struct must be created with a NULL callback function. This stucture will be the entry point for the child processes, and will be freed later, when none of the processes refers to it */ *cfg_child_cb_first = *cfg_child_cb_last = cfg_child_cb_new(NULL, NULL, NULL); if (!*cfg_child_cb_first) goto error; return 0; error: cfg_destroy(); return -1; }
/** * init module function */ static int mod_init(void) { bind_presence_t bind_presence; presence_api_t pres; bind_pua_t bind_pua; pua_api_t pua; bind_libxml_t bind_libxml; libxml_api_t libxml_api; bind_xcap_t bind_xcap; xcap_api_t xcap_api; char* sep; LM_DBG("start\n"); if (register_mi_mod(exports.name, mi_cmds)!=0) { LM_ERR("failed to register MI commands\n"); return -1; } if (dbmode <RLS_DB_DEFAULT || dbmode > RLS_DB_ONLY) { LM_ERR( "Invalid dbmode-set to default mode\n" ); dbmode = 0; } if(rls_server_address.s==NULL) { LM_ERR("server_address parameter not set in configuration file\n"); return -1; } rls_server_address.len= strlen(rls_server_address.s); if(!rls_integrated_xcap_server && xcap_root== NULL) { LM_ERR("xcap_root parameter not set\n"); return -1; } if(rls_outbound_proxy.s!=NULL) rls_outbound_proxy.len = strlen(rls_outbound_proxy.s); /* extract port if any */ if(xcap_root) { sep= strchr(xcap_root, ':'); if(sep) { char* sep2= NULL; sep2= strchr(sep+ 1, ':'); if(sep2) sep= sep2; str port_str; port_str.s= sep+ 1; port_str.len= strlen(xcap_root)- (port_str.s-xcap_root); if(str2int(&port_str, &xcap_port)< 0) { LM_ERR("converting string to int [port]= %.*s\n", port_str.len, port_str.s); return -1; } if(xcap_port< 0 || xcap_port> 65535) { LM_ERR("wrong xcap server port\n"); return -1; } *sep= '\0'; } } /* bind the SL API */ if (sl_load_api(&slb)!=0) { LM_ERR("cannot bind to SL API\n"); return -1; } /* load all TM stuff */ if(load_tm_api(&tmb)==-1) { LM_ERR("can't load tm functions\n"); return -1; } bind_presence= (bind_presence_t)find_export("bind_presence", 1,0); if (!bind_presence) { LM_ERR("Can't bind presence\n"); return -1; } if (bind_presence(&pres) < 0) { LM_ERR("Can't bind presence\n"); return -1; } pres_contains_event = pres.contains_event; pres_search_event = pres.search_event; pres_get_ev_list = pres.get_event_list; if (rls_expires_offset < 0 ) { LM_ERR( "Negative expires_offset, defaulted to zero\n" ); rls_expires_offset = 0; } if (dbmode == RLS_DB_ONLY) { pres_new_shtable = rls_new_shtable; pres_destroy_shtable = rls_destroy_shtable; pres_insert_shtable = rls_insert_shtable; pres_delete_shtable = rls_delete_shtable; pres_update_shtable = rls_update_shtable; pres_search_shtable = rls_search_shtable; pres_update_db_subs_timer = rls_update_db_subs_timer; } else { pres_new_shtable = pres.new_shtable; pres_destroy_shtable = pres.destroy_shtable; pres_insert_shtable = pres.insert_shtable; pres_delete_shtable = pres.delete_shtable; pres_update_shtable = pres.update_shtable; pres_search_shtable = pres.search_shtable; pres_update_db_subs_timer = pres.update_db_subs_timer; } pres_copy_subs = pres.mem_copy_subs; pres_extract_sdialog_info= pres.extract_sdialog_info; if(!pres_contains_event || !pres_get_ev_list || !pres_new_shtable || !pres_destroy_shtable || !pres_insert_shtable || !pres_delete_shtable || !pres_update_shtable || !pres_search_shtable || !pres_copy_subs || !pres_extract_sdialog_info) { LM_ERR("importing functions from presence module\n"); return -1; } rlsubs_table.len= strlen(rlsubs_table.s); rlpres_table.len= strlen(rlpres_table.s); rls_xcap_table.len= strlen(rls_xcap_table.s); db_url.len = db_url.s ? strlen(db_url.s) : 0; LM_DBG("db_url=%s/%d/%p\n", ZSW(db_url.s), db_url.len, db_url.s); xcap_db_url.len = xcap_db_url.s ? strlen(xcap_db_url.s) : 0; if(xcap_db_url.len==0) { xcap_db_url.s = db_url.s; xcap_db_url.len = db_url.len; } LM_DBG("db_url=%s/%d/%p\n", ZSW(xcap_db_url.s), xcap_db_url.len, xcap_db_url.s); rlpres_db_url.len = rlpres_db_url.s ? strlen(rlpres_db_url.s) : 0; if(rlpres_db_url.len==0) { rlpres_db_url.s = db_url.s; rlpres_db_url.len = db_url.len; } LM_DBG("db_url=%s/%d/%p\n", ZSW(rlpres_db_url.s), rlpres_db_url.len, rlpres_db_url.s); /* binding to mysql module */ if (db_bind_mod(&db_url, &rls_dbf)) { LM_ERR("Database module not found\n"); return -1; } if (db_bind_mod(&rlpres_db_url, &rlpres_dbf)) { LM_ERR("Database module not found\n"); return -1; } if (db_bind_mod(&xcap_db_url, &rls_xcap_dbf)) { LM_ERR("Database module not found\n"); return -1; } if (!DB_CAPABILITY(rls_dbf, DB_CAP_ALL)) { LM_ERR("Database module does not implement all functions" " needed by the module\n"); return -1; } if (!DB_CAPABILITY(rlpres_dbf, DB_CAP_ALL)) { LM_ERR("Database module does not implement all functions" " needed by the module\n"); return -1; } if (!DB_CAPABILITY(rls_xcap_dbf, DB_CAP_ALL)) { LM_ERR("Database module does not implement all functions" " needed by the module\n"); return -1; } rls_db = rls_dbf.init(&db_url); if (!rls_db) { LM_ERR("while connecting database\n"); return -1; } rlpres_db = rlpres_dbf.init(&rlpres_db_url); if (!rlpres_db) { LM_ERR("while connecting database\n"); return -1; } rls_xcap_db = rls_xcap_dbf.init(&xcap_db_url); if (!rls_xcap_db) { LM_ERR("while connecting database\n"); return -1; } /* verify table version */ if(db_check_table_version(&rls_dbf, rls_db, &rlsubs_table, W_TABLE_VERSION) < 0) { LM_ERR("error during table version check.\n"); return -1; } /* verify table version */ if(db_check_table_version(&rlpres_dbf, rlpres_db, &rlpres_table, P_TABLE_VERSION) < 0) { LM_ERR("error during table version check.\n"); return -1; } /* verify table version */ if(db_check_table_version(&rls_xcap_dbf, rls_xcap_db, &rls_xcap_table, X_TABLE_VERSION) < 0) { LM_ERR("error during table version check.\n"); return -1; } if (dbmode != RLS_DB_ONLY) { if(hash_size<=1) hash_size= 512; else hash_size = 1<<hash_size; rls_table= pres_new_shtable(hash_size); if(rls_table== NULL) { LM_ERR("while creating new hash table\n"); return -1; } if(rls_reload_db_subs!=0) { if(rls_restore_db_subs()< 0) { LM_ERR("while restoring rl watchers table\n"); return -1; } } } if(rls_db) rls_dbf.close(rls_db); rls_db = NULL; if(rlpres_db) rlpres_dbf.close(rlpres_db); rlpres_db = NULL; if(rls_xcap_db) rls_xcap_dbf.close(rls_xcap_db); rls_xcap_db = NULL; if(waitn_time<= 0) waitn_time= 5; if(rls_notifier_poll_rate<= 0) rls_notifier_poll_rate= 10; if(rls_notifier_processes<= 0) rls_notifier_processes= 1; /* bind libxml wrapper functions */ if((bind_libxml=(bind_libxml_t)find_export("bind_libxml_api", 1, 0))== NULL) { LM_ERR("can't import bind_libxml_api\n"); return -1; } if(bind_libxml(&libxml_api)< 0) { LM_ERR("can not bind libxml api\n"); return -1; } XMLNodeGetAttrContentByName= libxml_api.xmlNodeGetAttrContentByName; XMLDocGetNodeByName= libxml_api.xmlDocGetNodeByName; XMLNodeGetNodeByName= libxml_api.xmlNodeGetNodeByName; XMLNodeGetNodeContentByName= libxml_api.xmlNodeGetNodeContentByName; if(XMLNodeGetAttrContentByName== NULL || XMLDocGetNodeByName== NULL || XMLNodeGetNodeByName== NULL || XMLNodeGetNodeContentByName== NULL) { LM_ERR("libxml wrapper functions could not be bound\n"); return -1; } /* bind pua */ bind_pua= (bind_pua_t)find_export("bind_pua", 1,0); if (!bind_pua) { LM_ERR("Can't bind pua\n"); return -1; } if (bind_pua(&pua) < 0) { LM_ERR("mod_init Can't bind pua\n"); return -1; } if(pua.send_subscribe == NULL) { LM_ERR("Could not import send_subscribe\n"); return -1; } pua_send_subscribe= pua.send_subscribe; if(pua.get_record_id == NULL) { LM_ERR("Could not import get_record_id\n"); return -1; } pua_get_record_id= pua.get_record_id; if(pua.get_subs_list == NULL) { LM_ERR("Could not import get_subs_list\n"); return -1; } pua_get_subs_list= pua.get_subs_list; if(!rls_integrated_xcap_server) { /* bind xcap */ bind_xcap= (bind_xcap_t)find_export("bind_xcap", 1, 0); if (!bind_xcap) { LM_ERR("Can't bind xcap_client\n"); return -1; } if (bind_xcap(&xcap_api) < 0) { LM_ERR("Can't bind xcap\n"); return -1; } xcap_GetNewDoc= xcap_api.getNewDoc; if(xcap_GetNewDoc== NULL) { LM_ERR("Can't import xcap_client functions\n"); return -1; } } if (rlpres_clean_period < 0) rlpres_clean_period = clean_period; if (clean_period > 0) register_timer(rlsubs_table_update, 0, clean_period); if (rlpres_clean_period > 0) register_timer(rls_presentity_clean, 0, rlpres_clean_period); if(dbmode == RLS_DB_ONLY) { if ((rls_notifier_id = shm_malloc(sizeof(int) * rls_notifier_processes)) == NULL) { LM_ERR("allocating shared memory\n"); return -1; } register_basic_timers(rls_notifier_processes); } else register_timer(timer_send_notify, 0, waitn_time); if ((rls_update_subs_lock = lock_alloc()) == NULL) { LM_ERR("Failed to alloc rls_update_subs_lock\n"); return -1; } if (lock_init(rls_update_subs_lock) == NULL) { LM_ERR("Failed to init rls_updae_subs_lock\n"); return -1; } return 0; }
void main_loop(const char *host_lock_path, const char *master_lock_path, const char *fence_directory, char **other_lock_paths, int n_other_lock_paths) { struct lock host_lock, master_lock; struct lock *other_locks; int *host_has_self_fenced; enum state state; int i; int spinner_idx = 0; lock_init(&host_lock, host_lock_path, fence_directory); lock_init(&master_lock, master_lock_path, fence_directory); other_locks = (struct lock*) malloc(n_other_lock_paths * sizeof (struct lock)); host_has_self_fenced = (int *) malloc(n_other_lock_paths * sizeof(int)); if (!other_locks || !host_has_self_fenced) abort (); for (i = 0; i < n_other_lock_paths; i++) { lock_init(other_locks + i, *(other_lock_paths + i), fence_directory); *(host_has_self_fenced + i) = 0; } while(1) { sleep(1); tickle_watchdog (); printf("\b\b\b[%c]", spinner[spinner_idx]); fflush(stdout); spinner_idx = (spinner_idx + 1) % (sizeof spinner); state = lock_acquire(&host_lock); if (state == ACQUIRED) { printf("I have joined the cluster and can safely start VMs.\n"); fflush(stdout); } if (state == LOST) { printf("I have lost my host lock, I must self-fence.\n"); exit(1); /* let the watchdog kill us */ } state = lock_acquire(&master_lock); if (state == ACQUIRED) { printf("I have taken the master role.\n"); fflush(stdout); } if (state == LOST) { printf("I have lost the master lock, I must self-fence.\n"); exit(1); /* let the watchdog kill us */ } if (master_lock.acquired) { for (i = 0; i < n_other_lock_paths; i++) { if (*(host_has_self_fenced + i)) { /* We have already restarted this host's VMs after it self-fenced. We wait for it to come back online. */ if (is_lock_held(other_locks + i)) { printf("Another host has re-locked %s.\n", (other_locks + i)->filename); fflush(stdout); *(host_has_self_fenced + i) = 0; /* We will now start competing with this host for its lock. */ } } else { /* We constantly try to acquire another host's lock to sieze its resources and restart its VMs. */ state = lock_acquire(other_locks + i); if (state == ACQUIRED) { printf("I have sized the lock %s: It must have self-fenced. I should restart VMs.\n", (other_locks + i)->filename); fflush(stdout); *(host_has_self_fenced + i) = 1; lock_release(other_locks + i); } } } } } }
static int pike_init(void) { int rt; LM_INFO("initializing...\n"); /* alloc the timer lock */ timer_lock=lock_alloc(); if (timer_lock==0) { LM_ERR(" alloc locks failed!\n"); goto error1; } /* init the lock */ if (lock_init(timer_lock)==0){ LM_ERR(" init lock failed\n"); goto error1; } /* init the IP tree */ if ( init_ip_tree(max_reqs)!=0 ) { LM_ERR(" ip_tree creation failed!\n"); goto error2; } /* init timer list */ timer = (struct list_link*)shm_malloc(sizeof(struct list_link)); if (timer==0) { LM_ERR(" cannot alloc shm mem for timer!\n"); goto error3; } timer->next = timer->prev = timer; /* registering timing functions */ register_timer( "pike-clean", clean_routine , 0, 1 ); register_timer( "pike-swap", swap_routine , 0, time_unit ); if (pike_route_s && *pike_route_s) { rt = get_script_route_ID_by_name( pike_route_s, rlist, RT_NO); if (rt<1) { LM_ERR("route <%s> does not exist\n",pike_route_s); return -1; } /* register the script callback to get all requests and replies */ if (register_script_cb( run_pike_route , PARSE_ERR_CB|REQ_TYPE_CB|RPL_TYPE_CB|PRE_SCRIPT_CB, (void*)(long)rt )!=0 ) { LM_ERR("failed to register script callbacks\n"); goto error3; } } if((pike_event_id = evi_publish_event(pike_block_event)) == EVI_ERROR) LM_ERR("cannot register pike flood start event\n"); return 0; error3: destroy_ip_tree(); error2: lock_destroy(timer_lock); error1: if (timer_lock) lock_dealloc(timer_lock); timer_lock = 0; return -1; }
int Y_LockInit() { return lock_init()->id; }