static char *pick_symlink_target(const char *symlink_path) { struct dir_info *dir; struct dir_entry_info *entry; size_t r; char *path, *rel_path; dir = pick_dir(); if (tests_random_no(100) < 10) return dir_path(dir, make_name(dir)); r = tests_random_no(dir->number_of_entries); entry = dir->first; while (entry && r) { entry = entry->next; --r; } if (!entry) entry = dir->first; if (!entry) return dir_path(dir, make_name(dir)); path = dir_path(dir, entry->name); if (tests_random_no(20) < 10) return path; rel_path = relative_path(symlink_path, path); free(path); return rel_path; }
static char *pick_rename_name(struct dir_info **parent, struct dir_entry_info **rename_entry, int isdir) { struct dir_info *dir = pick_dir(); struct dir_entry_info *entry; size_t r; *parent = dir; *rename_entry = NULL; if (grow || tests_random_no(20) < 10) return copy_string(make_name(dir)); r = tests_random_no(dir->number_of_entries); entry = dir->first; while (entry && r) { entry = entry->next; --r; } if (!entry) entry = dir->first; if (!entry || (entry->type == 'd' && entry->entry.dir->number_of_entries != 0)) return copy_string(make_name(dir)); if ((isdir && entry->type != 'd') || (!isdir && entry->type == 'd')) return copy_string(make_name(dir)); *rename_entry = entry; return copy_string(entry->name); }
/* Randomly select something to do with a directory */ static void operate_on_dir(struct dir_info *dir) { size_t r; struct dir_entry_info *entry; struct file_info *file; r = tests_random_no(14); if (r == 0 && grow) /* When growing, 1 time in 14 create a file */ file_new(dir, make_name(dir)); else if (r == 1 && grow) /* When growing, 1 time in 14 create a directory */ dir_new(dir, make_name(dir)); else if (r == 2 && grow && (file = pick_file()) != NULL) /* When growing, 1 time in 14 create a hard link */ link_new(dir, make_name(dir), file); else if (r == 3 && grow && tests_random_no(5) == 0) /* When growing, 1 time in 70 create a symbolic link */ symlink_new(dir, make_name(dir)); else { /* Otherwise randomly select an entry to operate on */ r = tests_random_no(dir->number_of_entries); entry = dir->first; while (entry && r) { entry = entry->next; --r; } if (entry) operate_on_entry(entry); } }
void sync_const() { String s; Form2->Edit1->Text = get_nb(); Form2->Edit2->Text = get_k(); Form2->Edit3->Text = make_name(get_Pb()); Form2->Edit4->Text = make_name(get_E()); Form2->Edit5->Text = make_name(get_G()); }
/* Outputs all addresses in the table through subwrite. subwrite must be * a function returning >=0 on success, -1 on error, and taking * arguments (char* string, unsigned int length). It will be called once * per address and should take care of newline or whatever needed for * the output form. */ unsigned long sub_sql_putsubs(struct subdbinfo *info, const char *table, unsigned long hash_lo, unsigned long hash_hi, int subwrite()) /* write function. */ { void *result; unsigned long no = 0L; char strnum[FMT_ULONG]; stralloc_copyb(¶ms[0],strnum,fmt_ulong(strnum,hash_lo)); stralloc_copyb(¶ms[1],strnum,fmt_ulong(strnum,hash_hi)); make_name(info,table?"_":0,table,0); /* main query */ stralloc_copys(&query,"SELECT address FROM "); stralloc_cat(&query,&name); stralloc_cats(&query," WHERE "); stralloc_cats(&query,sql_putsubs_where_defn); result = sql_select(info,&query,2,params); no = 0; while (sql_fetch_row(info,result,1,&addr)) { if (subwrite(addr.s,addr.len) == -1) die_write(); no++; /* count for list-list fxn */ } sql_free_result(info,result); return no; }
Pbase start_cl(TOK t, Pname c, Pname b) { if (c == 0) c = new name(make_name('C')); //error('d',"c: %d %s",c->base,c->string); Pname n = c->tname(t); /* t ignored */ n->where = curloc; Pbase bt = (Pbase)n->tp; /* COBJ */ if (bt->base != COBJ) { error("twoDs of%n:%t andC",n,bt); error('i', "can't recover from previous errors"); } Pclass occl = ccl; ccl = (Pclass)bt->b_name->tp; /* CLASS */ if (ccl->defined) { error("C%n defined twice"); ccl->defined |= IN_ERROR; } ccl->defined |= DEF_SEEN; if (ccl->in_class = occl) occl->tn_list = modified_tn; // save mod-list modified_tn = 0; ccl->string = n->string; ccl->csu = t; if (b) ccl->clbase = b->tname(t); return bt; }
/* * seek_emty: walk database starting at an empty nonterminal node * (should fail) */ static void test_seek_nx(const atf_tc_t *tc) { isc_result_t result; dns_db_t *db = NULL; dns_dbiterator_t *iter = NULL; dns_name_t *seekname; dns_fixedname_t f1; UNUSED(tc); dns_fixedname_init(&f1); seekname = dns_fixedname_name(&f1); result = dns_test_begin(NULL, ISC_FALSE); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); result = dns_test_loaddb(&db, dns_dbtype_cache, TEST_ORIGIN, atf_tc_get_md_var(tc, "X-filename")); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); result = dns_db_createiterator(db, 0, &iter); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); result = make_name("nonexistent." TEST_ORIGIN, seekname); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); result = dns_dbiterator_seek(iter, seekname); ATF_CHECK_EQ(result, ISC_R_NOTFOUND); dns_dbiterator_destroy(&iter); dns_db_detach(&db); dns_test_end(); }
int ph_mkostemps(char *nametemplate, int suffixlen, int flags) { int len = strlen(nametemplate); char *base = nametemplate + (len - suffixlen) - 1; int tlen = 0; int fd, retries = 100; while (*base == 'X' && base > nametemplate) { tlen++; base--; } if (tlen == 0) { errno = EINVAL; return -1; } base++; while (retries--) { make_name(base, tlen); fd = open(nametemplate, flags|O_RDWR|O_CREAT|O_EXCL, 0600); if (fd >= 0) { return fd; } if (errno != EEXIST) { return -1; } } return -1; }
static void SetInfo(void) { nsf_t * nsf = app.nsf; unsigned int ms; gchar *name = 0; unsigned int track = app.cur_track; pdebug("nsf : set info #%02u\n", track); ms = 0; if (!track || track > app.n_tracks) { ms = app.tracks[0].ms; } else { unsigned int tms = app.tracks[track].ms; ms = app.tracks[0].ms; name = g_strdup_printf("%s by %s track:%02d %02u:%02u copyright:%s :-)", nsf->song_name, nsf->artist_name, track, tms/60000u, tms%60000u/1000u, nsf->copyright); nosefart_ip.set_info_text(name); g_free(name); } name = make_name(nsf->song_name, nsf->artist_name, track, app.n_tracks); nosefart_ip.set_info(name, ms, 44100, 44100, 1); g_free(name); /* $$$ ? */ }
static HANDLE create_event(int sig, BOOL initial, BOOL errmsg, BOOL * exists) { char name[EVT_NAME_LEN]; HANDLE h; if (sig >= 0) make_name(name, sig); else name[0] = 0; if (exists) *exists = FALSE; if (!(h = CreateEventA(NULL, FALSE, initial, (name[0] ? name : NULL)))) { if (errmsg) fprintf(stderr, "CreateEvent(.,\"%s\"): Error=%ld\n", name, GetLastError()); return 0; } if (GetLastError() == ERROR_ALREADY_EXISTS) { if (!exists) { if (errmsg) fprintf(stderr, "CreateEvent(.,\"%s\"): Exists\n", name); CloseHandle(h); return 0; } *exists = TRUE; } return h; }
static int sig_event(int sig) { char name[EVT_NAME_LEN]; HANDLE h; make_name(name, sig); if (!(h = OpenEventA(EVENT_MODIFY_STATE, FALSE, name))) { make_name(name, EVT_RUNNING); if (!(h = OpenEvent(EVENT_MODIFY_STATE, FALSE, name))) return -1; CloseHandle(h); return 0; } SetEvent(h); CloseHandle(h); return 1; }
/** * initialize the in/out connections * * @param basename base name for abstract namespace * * @return unix status */ static int sim_init_conn(char *basename) { union name_t name; size_t size; int fd, i; DEBUG("initializing network connections (basename \"%s\")", basename); // create ctl channel fd = simctl = socket(remote_mode ? PF_INET : PF_LOCAL, SOCK_DGRAM, 0); if (fd < 0) IBPANIC("can't create socket for ctl"); if (maxfd < fd) maxfd = fd; size = make_name(&name, 0, listen_to_port, "%s:ctl", basename); if (bind(fd, (struct sockaddr *)&name, size) < 0) IBPANIC("can't bind socket %d to name %s", fd, get_name(&name)); if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0) IBPANIC("can't set non blocking flags for ctl"); for (i = 0; i < IBSIM_MAX_CLIENTS; i++) { fd = socket(remote_mode ? PF_INET : PF_LOCAL, SOCK_DGRAM, 0); if (fd < 0) IBPANIC("can't create socket for conn %d", i); if (maxfd < fd) maxfd = fd; size = make_name(&name, 0, listen_to_port + i + 1, "%s:out%d", basename, i); if (bind(fd, (struct sockaddr *)&name, size) < 0) IBPANIC("can't bind socket %d to name %s", fd, get_name(&name)); if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0) IBPANIC("can't set non blocking flags for " "client conn %d", i); DEBUG("opening net connection fd %d %s", fd, get_name(&name)); clients[i].fd = fd; } return 0; }
static const char *remove_table(struct subdbinfo *info, const char *suffix1, const char *suffix2) { make_name(info,suffix1,suffix2,1); if (sql_table_exists(info,name.s) == 0) return 0; return sql_drop_table(info,name.s); }
static int event_exists(int sig) { char name[EVT_NAME_LEN]; HANDLE h; make_name(name, sig); if (!(h = OpenEventA(EVENT_MODIFY_STATE, FALSE, name))) return 0; CloseHandle(h); return 1; }
void name_gather (void) { /* Buffer able to hold a single name. */ static struct name *buffer = NULL; struct name_elt *ep; if (same_order_option) { static int change_dir; while ((ep = name_next_elt (0)) && ep->type == NELT_CHDIR) change_dir = chdir_arg (xstrdup (ep->v.name)); if (ep) { free_name (buffer); buffer = make_name (ep->v.name); buffer->change_dir = change_dir; buffer->next = 0; buffer->found_count = 0; buffer->matching_flags = matching_flags; buffer->directory = NULL; buffer->parent = NULL; buffer->cmdline = true; namelist = nametail = buffer; } else if (change_dir) addname (0, change_dir, false, NULL); } else { /* Non sorted names -- read them all in. */ int change_dir = 0; for (;;) { int change_dir0 = change_dir; while ((ep = name_next_elt (0)) && ep->type == NELT_CHDIR) change_dir = chdir_arg (xstrdup (ep->v.name)); if (ep) addname (ep->v.name, change_dir, true, NULL); else { if (change_dir != change_dir0) addname (NULL, change_dir, false, NULL); break; } } } }
void read_stat(char *proc_id,override_type *entry,int k,int uid) { char *stat_filename=make_name(proc_id,1); int done=0; char *field; FILE *fp; int n; /* current field number */ char *proc_name; unsigned utime; int priority; int nice; if ((fp=fopen(stat_filename,"r"))==NULL) fprintf(stderr,"Error: failed to open '%s'!\n",stat_filename); else { for (n=0; !done && (field=get_next_field(fp)); n++) switch (n) { case 1: /* proc name */ proc_name=alloca(strlen(field)+1); strcpy(proc_name,strip_parens(field)); break; case 13: /* utime */ utime=atol(field)/(float)USER_HZ; break; case 17: /* priority */ priority=atoi(field); break; case 18: /* nice */ nice=atoi(field); done=1; /* end iteration after last interesting field */ break; } fclose(fp); } if (done) /* reached last field OK */ { /* if exceeded defined kill threshold and not an exception... */ if (k>0 && (!entry || entry->elapsed!=-1) && utime>k) kill_proc(atoi(proc_id),uid,k); else adjust_sched(atoi(proc_id),proc_name,utime,priority,nice,entry); } }
static void nosefart_song_info(char *filename, char **title, int *length) { nsf_t * nsf; *length = -1; *title = 0; nsf = load(filename); if (nsf) { *title = make_name(nsf->song_name, nsf->artist_name, -1, nsf->num_songs); *length = nsf->song_frames[0] * 1000u / (unsigned int)nsf->playback_rate; nsf_free(&nsf); } }
int get_owner(char *proc_id) { char *filename=make_name(proc_id,0); int uid=-1; /* error returned if stat not completed */ struct stat file_stat; if (stat(filename,&file_stat)!=0) fprintf(stderr,"Error: failed to stat '%s'!\n",filename); else uid=file_stat.st_uid; return(uid); }
/* Searches the subscriber log and outputs via subwrite(s,len) any entry * that matches search. A '_' is search is a wildcard. Any other * non-alphanum/'.' char is replaced by a '_'. */ void sub_sql_searchlog(struct subdbinfo *info, const char *table, char *search, /* search string */ int subwrite()) /* output fxn */ { void *result; datetime_sec when; struct datetime dt; char date[DATE822FMT]; int nparams; char strnum[FMT_ULONG]; make_name(info,table?"_":0,table,0); /* SELECT (*) FROM list_slog WHERE fromline LIKE '%search%' OR address */ /* LIKE '%search%' ORDER BY tai; */ /* The '*' is formatted to look like the output of the non-mysql version */ /* This requires reading the entire table, since search fields are not */ /* indexed, but this is a rare query and time is not of the essence. */ stralloc_copys(&query,"SELECT "); stralloc_cats(&query,sql_searchlog_select_defn); stralloc_cats(&query," FROM "); stralloc_cat(&query,&name); stralloc_cats(&query,"_slog"); if (*search) { /* We can afford to wait for LIKE '%xx%' */ stralloc_copys(¶ms[0],search); stralloc_copys(¶ms[1],search); nparams = 2; stralloc_cats(&query," WHERE "); stralloc_cats(&query,sql_searchlog_where_defn); } else nparams = 0; /* ordering by tai which is an index */ stralloc_cats(&query," ORDER by tai"); result = sql_select(info,&query,nparams,params); while (sql_fetch_row(info,result,2,params)) { stralloc_0(¶ms[0]); (void)scan_ulong(params[0].s,&when); datetime_tai(&dt,when); stralloc_copyb(¶ms[0],date,date822fmt(date,&dt)-1); stralloc_cats(¶ms[0],": "); stralloc_catb(¶ms[0],strnum,fmt_ulong(strnum,when)); stralloc_cats(¶ms[0]," "); stralloc_cat(¶ms[0],¶ms[1]); if (subwrite(params[0].s,params[0].len) == -1) die_write(); } sql_free_result(info,result); }
char * get_name(ADDR mem, int idx, Elf64_Sym *symtab, int symcount, int symstart, char *strtab, char *count_strtab) { char *name1; if (idx == 0) { if ((name1 = find_and_get_str(mem, symtab, symcount, symstart, strtab)) == 0) { /* manufacture a name */ name1 = make_name(mem); } } else name1 = count_strtab + idx; return name1; }
/* Randomly select something to do with a directory */ static void operate_on_dir(struct dir_info *dir) { size_t r; struct dir_entry_info *entry; r = tests_random_no(12); if (r == 0 && grow) /* When growing, 1 time in 12 create a file */ file_new(dir, make_name(dir)); else if (r == 1 && grow) /* When growing, 1 time in 12 create a directory */ dir_new(dir, make_name(dir)); else { /* Otherwise randomly select an entry to operate on */ r = tests_random_no(dir->number_of_entries); entry = dir->first; while (entry && r) { entry = entry->next; --r; } if (entry) operate_on_entry(entry); } }
/* seek: walk database starting at a particular node */ static void test_seek(const atf_tc_t *tc) { isc_result_t result; dns_db_t *db = NULL; dns_dbiterator_t *iter = NULL; dns_dbnode_t *node = NULL; dns_name_t *name, *seekname; dns_fixedname_t f1, f2; int i = 0; UNUSED(tc); dns_fixedname_init(&f1); name = dns_fixedname_name(&f1); dns_fixedname_init(&f2); seekname = dns_fixedname_name(&f2); result = dns_test_begin(NULL, ISC_FALSE); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); result = dns_test_loaddb(&db, dns_dbtype_cache, TEST_ORIGIN, atf_tc_get_md_var(tc, "X-filename")); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); result = dns_db_createiterator(db, 0, &iter); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); result = make_name("c." TEST_ORIGIN, seekname); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); result = dns_dbiterator_seek(iter, seekname); ATF_CHECK_EQ(result, ISC_R_SUCCESS); while (result == ISC_R_SUCCESS) { result = dns_dbiterator_current(iter, &node, name); if (result == DNS_R_NEWORIGIN) result = ISC_R_SUCCESS; ATF_CHECK_EQ(result, ISC_R_SUCCESS); dns_db_detachnode(db, &node); result = dns_dbiterator_next(iter); i++; } ATF_CHECK_EQ(i, atoi(atf_tc_get_md_var(tc, "X-nodes"))); dns_dbiterator_destroy(&iter); dns_db_detach(&db); dns_test_end(); }
static const char *create_table(struct subdbinfo *info, const char *suffix1, const char *suffix2, const char *definition) { make_name(info,suffix1,suffix2,1); if (sql_table_exists(info,name.s) > 0) return 0; stralloc_copys(&query,"CREATE TABLE "); stralloc_cats(&query,name.s); stralloc_cats(&query," ("); stralloc_cats(&query,definition); stralloc_cats(&query,")"); stralloc_0(&query); return sql_create_table(info,query.s); }
//functions FullConnection(Layer* f, Layer* t, const vector<int>& d = empty_list_of<int>(), FullConnection* s = 0): Connection(make_name(f, t, d), f, t), source(s), paramRange(source ? source->paramRange : WeightContainer::instance().new_parameters(this->from->output_size() * this->to->input_size(), this->from->name, this->to->name, name)) { if (source) { WeightContainer::instance().link_layers(this->from->name, this->to->name, this->name, paramRange.first, paramRange.second); } set_delay(d); assert(num_weights() == (this->from->output_size() * this->to->input_size())); if (this->from->name != "bias" && this->from != this->to && !this->to->source) { this->to->source = this->from; } }
/*ARGSUSED*/ static int look_xmap(void *data, const prxmap_t *pmp, const char *object_name, int last, int doswap) { struct totals *t = data; const pstatus_t *Psp = Pstatus(Pr); char mname[PATH_MAX]; char *lname = NULL; char *ln; /* * If the mapping is not anon or not part of the heap, make a name * for it. We don't want to report the heap as a.out's data. */ if (!(pmp->pr_mflags & MA_ANON) || pmp->pr_vaddr + pmp->pr_size <= Psp->pr_brkbase || pmp->pr_vaddr >= Psp->pr_brkbase + Psp->pr_brksize) { lname = make_name(Pr, lflag, pmp->pr_vaddr, pmp->pr_mapname, mname, sizeof (mname)); } if (lname != NULL) { if ((ln = strrchr(lname, '/')) != NULL) lname = ln + 1; } else if ((pmp->pr_mflags & MA_ANON) || Pstate(Pr) == PS_DEAD) { lname = anon_name(mname, Psp, stacks, nstacks, pmp->pr_vaddr, pmp->pr_size, pmp->pr_mflags, pmp->pr_shmid, NULL); } (void) printf("%.*lX", addr_width, (ulong_t)pmp->pr_vaddr); printK(ROUNDUP_KB(pmp->pr_size), size_width); printK(pmp->pr_rss * (pmp->pr_pagesize / KILOBYTE), size_width); printK(ANON(pmp) * (pmp->pr_pagesize / KILOBYTE), size_width); printK(pmp->pr_locked * (pmp->pr_pagesize / KILOBYTE), size_width); (void) printf(lname ? " %4s %-6s %s\n" : " %4s %s\n", pagesize(pmp), mflags(pmp->pr_mflags), lname); t->total_size += ROUNDUP_KB(pmp->pr_size); t->total_rss += pmp->pr_rss * (pmp->pr_pagesize / KILOBYTE); t->total_anon += ANON(pmp) * (pmp->pr_pagesize / KILOBYTE); t->total_locked += (pmp->pr_locked * (pmp->pr_pagesize / KILOBYTE)); return (0); }
int sub_sql_issub(struct subdbinfo *info, const char *table, const char *userhost, stralloc *recorded) { unsigned int j; void *result; int ret; /* SELECT address FROM list WHERE address = 'userhost' AND hash */ /* BETWEEN 0 AND 52. Without the hash restriction, we'd make it */ /* even easier to defeat. Just faking sender to the list name would*/ /* work. Since sender checks for posts are bogus anyway, I don't */ /* know if it's worth the cost of the "WHERE ...". */ make_name(info,table?"_":0,table,0); /* Lower-case the domain portion */ stralloc_copys(&addr,userhost); j = byte_rchr(addr.s,addr.len,'@'); if (j == addr.len) return 0; case_lowerb(addr.s + j + 1,addr.len - j - 1); stralloc_copys(&query,"SELECT address FROM "); stralloc_cat(&query,&name); stralloc_cats(&query," WHERE "); stralloc_cats(&query,sql_issub_where_defn); result = sql_select(info,&query,1,&addr); if (!sql_fetch_row(info,result,1,&addr)) ret = 0; else { /* we need to return the actual address as other dbs may accept * user-*@host, but we still want to make sure to send to e.g the * correct moderator address. */ if (recorded != 0) { stralloc_copy(recorded,&addr); stralloc_0(recorded); } ret = 1; } sql_free_result(info,result); return ret; }
Pbase end_enum(Pname n, Pname b) { if (n == 0) n = new name(make_name('E')); n = n->tname(ENUM); Pbase bt = (Pbase)n->tp; if (bt->base != EOBJ) { error("twoDs of%n:%t and enum",n,bt); error('i', "can't recover from previous errors"); } Penum en = (Penum)bt->b_name->tp; en->e_body = 2; en->mem = name_unlist((class nlist *)b); if (en->defined) { error("enum%n defined twice",n); en->defined |= IN_ERROR; } en->defined |= DEF_SEEN; return bt; }
/* Add a name to the namelist. */ struct name * addname (char const *string, int change_dir, bool cmdline, struct name *parent) { struct name *name = make_name (string); name->prev = nametail; name->next = NULL; name->found_count = 0; name->matching_flags = matching_flags; name->change_dir = change_dir; name->directory = NULL; name->parent = parent; name->cmdline = cmdline; if (nametail) nametail->next = name; else namelist = name; nametail = name; return name; }
bool_t linphone_gtk_init_instance(const char *app_name, const char *addr_to_call){ pipe_name=make_name(app_name); ortp_pipe_t p=ortp_client_pipe_connect(pipe_name); if (p!=(ortp_pipe_t)-1){ uint8_t buf[256]={0}; g_message("There is already a running instance."); if (addr_to_call!=NULL){ //strncpy((char*)buf,addr_to_call,sizeof(buf)-1); sprintf((char*)buf, "%s %s %s", addr_to_call, aupkg_file, (g_enable_video==FALSE)?"audio":"video"); } if (ortp_pipe_write(p,buf,sizeof(buf))==-1){ g_error("Fail to send wakeup command to running instance: %s",strerror(errno)); }else{ g_message("Message to running instance sent."); } ortp_client_pipe_close(p); return FALSE; }else{ linphone_gtk_init_pipe(pipe_name); } return TRUE; }
bool_t linphone_gtk_init_instance(const char *app_name, int option, const char *addr_to_call){ ortp_pipe_t p; pipe_name=make_name(app_name); p=ortp_client_pipe_connect(pipe_name); if (p!=(ortp_pipe_t)-1){ uint8_t buf[256]={0}; g_message("There is already a running instance."); if (addr_to_call!=NULL){ sprintf((char *)buf,"%i%s",option,addr_to_call); } else { sprintf((char *)buf,"%i",option); } if (ortp_pipe_write(p,buf,sizeof(buf))==-1){ g_error("Fail to send wakeup command to running instance: %s",strerror(errno)); }else{ g_message("Message to running instance sent."); } ortp_client_pipe_close(p); return FALSE; }else{ linphone_gtk_init_pipe(pipe_name); } return TRUE; }