static void uartclose(Chan *c) { Uart *p; if(c->qid.type & QTDIR) return; if((c->flag & COPEN) == 0) return; switch(NETTYPE(c->qid.path)){ case Ndataqid: case Nctlqid: p = uart[NETID(c->qid.path)]; qlock(p); if(--(p->opens) == 0){ qclose(p->iq); ilock(&p->rlock); p->ir = p->iw = p->istage; iunlock(&p->rlock); /* */ qhangup(p->oq, nil); if(!waserror()){ uartdrainoutput(p); poperror(); } qclose(p->oq); uartdisable(p); p->dcd = p->dsr = p->dohup = 0; } qunlock(p); break; } }
static bool test_all(void){ test( linux_file_vfs_open() ); // write int fid = qopen( "./a.txt", O_RDWR | O_CREAT | O_TRUNC, NULL ); test( 0 != fid ); test( 5 == qwrite( fid, "12345", 5 ) ); { struct qstat buf; test( qfstat( fid, &buf ) ); test( 5 == buf.size ); } test( qclose( fid ) ); fid = 0; // read fid = qopen( "./a.txt", O_RDONLY, NULL ); test( 0 != fid ); { struct qstat buf; test( qfstat( fid, &buf ) ); test( 5 == buf.size ); } char buf[100]; memset( buf, 0, sizeof( buf ) ); test( 5 == qread( fid, buf, sizeof(buf) ) ); test( 0 == memcmp( buf, "12345", 5 ) ); test( qclose( fid ) ); fid = 0; return true; }
static void greclose(Conv *c) { qclose(c->rq); qclose(c->wq); qclose(c->eq); ipmove(c->laddr, IPnoaddr); ipmove(c->raddr, IPnoaddr); c->lport = 0; c->rport = 0; }
static void pipeclose(Chan *c) { Pipe *p; p = c->aux; qlock(p); if(c->flag & COPEN){ /* * closing either side hangs up the stream */ switch(NETTYPE(c->qid.path)){ case Qdata0: p->qref[0]--; if(p->qref[0] == 0){ qhangup(p->q[1], 0); qclose(p->q[0]); } break; case Qdata1: p->qref[1]--; if(p->qref[1] == 0){ qhangup(p->q[0], 0); qclose(p->q[1]); } break; } } /* * if both sides are closed, they are reusable */ if(p->qref[0] == 0 && p->qref[1] == 0){ qreopen(p->q[0]); qreopen(p->q[1]); } /* * free the structure on last close */ p->ref--; if(p->ref == 0){ qunlock(p); free(p->q[0]); free(p->q[1]); free(p); } else qunlock(p); }
static void espclose(Conv *c) { Espcb *ecb; qclose(c->rq); qclose(c->wq); qclose(c->eq); ipmove(c->laddr, IPnoaddr); ipmove(c->raddr, IPnoaddr); ecb = (Espcb*)c->ptcl; free(ecb->espstate); free(ecb->ahstate); memset(ecb, 0, sizeof(Espcb)); }
void iprouterclose(struct Fs *f) { qlock(&(&f->iprouter)->qlock); f->iprouter.opens--; if (f->iprouter.opens == 0) qclose(f->iprouter.q); qunlock(&(&f->iprouter)->qlock); }
/* * detach a device from an interface, close the interface * called with ifc->conv closed */ static char* ipifcunbind(Ipifc *ifc) { Proc *up = externup(); char *err; if(waserror()){ wunlock(ifc); nexterror(); } wlock(ifc); /* dissociate routes */ if(ifc->medium != nil && ifc->medium->unbindonclose == 0) ifc->conv->inuse--; ifc->ifcid++; /* disassociate logical interfaces (before zeroing ifc->arg) */ while(ifc->lifc){ err = ipifcremlifc(ifc, ifc->lifc); /* * note: err non-zero means lifc not found, * which can't happen in this case. */ if(err) error(err); } /* disassociate device */ if(ifc->medium && ifc->medium->unbind) (*ifc->medium->unbind)(ifc); memset(ifc->dev, 0, sizeof(ifc->dev)); ifc->arg = nil; ifc->reassemble = 0; /* close queues to stop queuing of packets */ qclose(ifc->conv->rq); qclose(ifc->conv->wq); qclose(ifc->conv->sq); ifc->medium = nil; wunlock(ifc); poperror(); return nil; }
static void tkclose(Chan* c) { if(c->qid.type & QTDIR || (c->flag & COPEN) == 0) return; qlock(&tkevents.l); if(decref(&tkevents.inuse) == 0) qclose(tkevents.eq); qunlock(&tkevents.l); }
void netifclose(Netif *nif, Chan *c) { Netfile *f; int t; Netaddr *ap; if((c->flag & COPEN) == 0) return; t = NETTYPE(c->qid.path); if(t != Ndataqid && t != Nctlqid) return; f = nif->f[NETID(c->qid.path)]; qlock(&f->q); if(--(f->inuse) == 0){ if(f->prom){ qlock(&nif->q); if(--(nif->prom) == 0 && nif->promiscuous != nil) nif->promiscuous(nif->arg, 0); qunlock(&nif->q); f->prom = 0; } if(f->scan){ qlock(&nif->q); if(--(nif->_scan) == 0 && nif->scanbs != nil) nif->scanbs(nif->arg, 0); qunlock(&nif->q); f->prom = 0; f->scan = 0; } if(f->nmaddr){ qlock(&nif->q); t = 0; for(ap = nif->maddr; ap; ap = ap->next){ if(f->maddr[t/8] & (1<<(t%8))) netmulti(nif, f, ap->addr, 0); } qunlock(&nif->q); f->nmaddr = 0; } if(f->type < 0){ qlock(&nif->q); --(nif->all); qunlock(&nif->q); } f->owner[0] = 0; f->type = 0; f->bridge = 0; f->headersonly = 0; qclose(f->iq); } qunlock(&f->q); }
static void rudpclose(Conv *c) { Rudpcb *ucb; Reliable *r, *nr; Rudppriv *upriv; upriv = c->p->priv; iphtrem(&upriv->ht, c); /* force out any delayed acks */ ucb = (Rudpcb*)c->ptcl; qlock(&ucb->ql); for(r = ucb->r; r; r = r->next){ if(r->acksent != r->rcvseq) relsendack(c, r, 0); } qunlock(&ucb->ql); qclose(c->rq); qclose(c->wq); qclose(c->eq); ipmove(c->laddr, IPnoaddr); ipmove(c->raddr, IPnoaddr); c->lport = 0; c->rport = 0; ucb->headers = 0; ucb->randdrop = 0; qlock(&ucb->ql); for(r = ucb->r; r; r = nr){ if(r->acksent != r->rcvseq) relsendack(c, r, 0); nr = r->next; relhangup(c, r); relput(r); } ucb->r = 0; qunlock(&ucb->ql); }
static void udpclose(Conv *c) { Udpcb *ucb; Udppriv *upriv; upriv = c->p->priv; iphtrem(&upriv->ht, c); c->state = 0; qclose(c->rq); qclose(c->wq); qclose(c->eq); ipmove(c->laddr, IPnoaddr); ipmove(c->raddr, IPnoaddr); c->lport = 0; c->rport = 0; ucb = (Udpcb*)c->ptcl; ucb->headers = 0; }
/* * detach a device from an interface, close the interface * called with ifc->conv closed */ static char *ipifcunbind(struct Ipifc *ifc) { ERRSTACK(1); char *err; if (waserror()) { wunlock(&ifc->rwlock); nexterror(); } wlock(&ifc->rwlock); /* dissociate routes */ if (ifc->m != NULL && ifc->m->unbindonclose == 0) ifc->conv->inuse--; ifc->ifcid++; /* disassociate device */ if (ifc->m != NULL && ifc->m->unbind) (*ifc->m->unbind) (ifc); memset(ifc->dev, 0, sizeof(ifc->dev)); ifc->arg = NULL; ifc->reassemble = 0; /* close queues to stop queuing of packets */ qclose(ifc->conv->rq); qclose(ifc->conv->wq); qclose(ifc->conv->sq); /* disassociate logical interfaces */ while (ifc->lifc) { err = ipifcremlifc(ifc, ifc->lifc); if (err) error(err); } ifc->m = NULL; wunlock(&ifc->rwlock); poperror(); return NULL; }
static void print_to_error_file(const char *error_msg) { int file_id = qopen(ERROR_FILE, O_WRONLY | O_APPEND); if (file_id == -1) file_id = qcreate(ERROR_FILE, 511); if (file_id == -1) { msg("FATAL: print_to_error_file failed!\n"); return; } qwrite(file_id, error_msg, strlen(error_msg)); qclose(file_id); }
static void print_to_output_file(const char *output_msg) { int file_id = qopen(OUTPUT_FILE, O_WRONLY | O_APPEND); if (file_id == -1) file_id = qcreate(OUTPUT_FILE, 511); if (file_id == -1) { msg("FATAL: print_to_output_file failed!\n"); return; } qwrite(file_id, output_msg, strlen(output_msg)); qclose(file_id); }
/* * called with the Loop qlocked, * so only pushlink can mess with the queues */ static void closelink(Link *link, int dofree) { Queue *iq, *oq; Block *bp; ilock(link); iq = link->iq; oq = link->oq; bp = link->tq; link->tq = nil; link->tqtail = nil; link->tout = 0; link->tin = 0; timerdel(&link->ci); iunlock(link); if(iq != nil){ qclose(iq); if(dofree){ ilock(link); free(iq); link->iq = nil; iunlock(link); } } if(oq != nil){ qclose(oq); if(dofree){ ilock(link); free(oq); link->oq = nil; iunlock(link); } } freeblist(bp); }
static void uartclose(Chan *c) { Uart *p; if(c->qid.type & QTDIR) return; if((c->flag & COPEN) == 0) return; switch(NETTYPE(c->qid.path)){ case Ndataqid: case Nctlqid: p = uart[NETID(c->qid.path)]; qlock(p); if(--(p->opens) == 0){ uartdisable(p); qclose(p->iq); qclose(p->oq); p->ip = p->istage; } qunlock(p); break; } }
void dump_ctrees_in_file(std::map<ea_t, ctree_dump_line> &data_to_dump, qstring &crypto_prefix) { int file_id = create_open_file("ctrees.txt"); if (file_id != -1) { size_t crypt_prefix_len = crypto_prefix.length(); for (std::map<ea_t, ctree_dump_line>::iterator ctrees_iter = data_to_dump.begin(); ctrees_iter != data_to_dump.end() ; ctrees_iter ++) { qstring sha_hash; int err = get_hash_of_string((*ctrees_iter).second.ctree_for_hash, sha_hash); if (err == shaSuccess) { qstring dump_line = sha_hash + ";"; err = get_hash_of_string((*ctrees_iter).second.ctree_dump, sha_hash); if (err == shaSuccess) { dump_line += sha_hash + ";"; dump_line += (*ctrees_iter).second.ctree_dump; dump_line.cat_sprnt(";%d", (*ctrees_iter).second.func_depth); dump_line.cat_sprnt(";%08X", (*ctrees_iter).second.func_start); dump_line.cat_sprnt(";%08X", (*ctrees_iter).second.func_end); if (((*ctrees_iter).second.func_name.length() > crypt_prefix_len) && (crypt_prefix_len > 0) && ((*ctrees_iter).second.func_name.find(crypto_prefix) == 0)) dump_line.cat_sprnt(";E", (*ctrees_iter).second.func_end); else dump_line.cat_sprnt(";N", (*ctrees_iter).second.func_end); if (((*ctrees_iter).second.heuristic_flag)) dump_line.cat_sprnt(";H", (*ctrees_iter).second.func_end); else dump_line.cat_sprnt(";N", (*ctrees_iter).second.func_end); dump_line += "\n"; } qwrite(file_id, dump_line.c_str(), dump_line.length()); } if (err != shaSuccess) { logmsg(ERROR, "Error in computing SHA1 hash\r\n"); } } qclose(file_id); } else { logmsg(ERROR, "Failed to open file for dumping ctress\r\n"); } }
/* * called with ifc wlock'd */ static void pppunbind(Ipifc * ifc) { PPP *ppp = ifc->arg; if (ppp == nil) return; if (ppp->readp) postnote(ppp->readp, 1, "unbind", 0); if (ppp->timep) postnote(ppp->timep, 1, "unbind", 0); /* wait for kprocs to die */ while (ppp->readp != 0 || ppp->timep != 0) udelay_sched(300 * 1000); pppclose(ppp); qclose(ifc->conv->eq); ifc->arg = nil; }
void fsysproc(void *dummy) { u32int i; Block *db; USED(dummy); for(i=0; i<fsys->nblock; i++){ fsscanblock = i; if((db = fsysreadblock(fsys, i)) != nil) qwrite(qcmp, db, i); } fsscanblock = i; qclose(qcmp); if(statustime) print("# %T fsys proc exiting\n"); runlock(&endlk); }
void cmpproc(void *dummy) { uchar *data; Block *db; u32int bno, bsize; uchar score[VtScoreSize]; uchar score1[VtScoreSize]; USED(dummy); if(incremental) vtfilelock(vscores, VtOREAD); bsize = fsys->blocksize; while((db = qread(qcmp, &bno)) != nil){ data = db->data; sha1(data, vtzerotruncate(VtDataType, data, bsize), score, nil); if(incremental){ if(vtfileblockscore(vscores, bno, score1) < 0) sysfatal("cmpproc vtfileblockscore %d: %r", bno); }else{ if(Bseek(&bscores, (vlong)bno*VtScoreSize, 0) < 0) sysfatal("cmpproc Bseek: %r"); if(Bread(&bscores, score1, VtScoreSize) != VtScoreSize) sysfatal("cmpproc Bread: %r"); } if(memcmp(score, score1, VtScoreSize) != 0){ nchange++; if(verbose) print("# block %ud: old %V new %V\n", bno, score1, score); qwrite(qventi, db, bno); }else blockput(db); } qclose(qventi); if(incremental) vtfileunlock(vscores); if(statustime) print("# %T cmp proc exiting\n"); runlock(&endlk); }
int main() { char dpb[ 48 ]; int i = 0, len; long status[ 20 ]; dpb[ i++ ] = isc_dpb_version1; dpb[ i++ ] = isc_dpb_user_name; len = strlen( USER ); dpb[ i++ ] = ( char ) len; strncpy( &( dpb[ i ] ), USER, len ); i += len; dpb[ i++ ] = isc_dpb_password; len = strlen( PASSWORD ); dpb[ i++ ] = len; strncpy( &( dpb[ i ] ), PASSWORD, len ); i += len; if( isc_attach_database( status, 0, DATABASE, &db, i, dpb ) ) ERREXIT( status, 1 ); execute( "DROP TABLE TESTE" ); execute( "CREATE TABLE TESTE (code smallint)" ); execute( "INSERT INTO TESTE (code) VALUES (100)" ); query( "SELECT * FROM TESTE" ); while( fetch() == 0 ) printf( "%s\n", getdata( 0 ) ); qclose(); if( isc_detach_database( status, &db ) ) ERREXIT( status, 1 ); return 1; }
/* * be extremely careful when calling this, * as there is no reference accounting */ void qfree(struct queue *q) { qclose(q); kfree(q); }
bool idaapi extract_all_types(void *ud) { logmsg(DEBUG, "extract_types()\n"); // find vtables in the binary search_objects(false); qvector <VTBL_info_t>::iterator vtbl_iter; std::map<ea_t, VTBL_info_t> vtbl_map; for (vtbl_iter = vtbl_t_list.begin(); vtbl_iter != vtbl_t_list.end(); vtbl_iter++) vtbl_map[(*vtbl_iter).ea_begin] = (*vtbl_iter); int file_id = create_open_file("types.txt"); if (file_id == -1) { logmsg(ERROR, "Failed to open file for dumping types.txt\r\n"); return false; } int struct_no = 0; for (vtbl_iter = vtbl_t_list.begin(); vtbl_iter != vtbl_t_list.end(); vtbl_iter++) { qstring info_msg; info_msg.cat_sprnt("Processing vtable %s\n", (*vtbl_iter).vtbl_name.c_str()); logmsg(DEBUG, info_msg.c_str()); qstring type_name; type_name.sprnt("struc_2_%d", struct_no); ea_t cur_vt_ea = (*vtbl_iter).ea_begin; int struct_subno = 0; qvector <qstring> types_to_merge; for (ea_t addr = get_first_dref_to(cur_vt_ea); addr != BADADDR; addr = get_next_dref_to(cur_vt_ea, addr)) { qstring name; if (get_func_name(&name, addr) <= 0) continue; qstring info_msg1; info_msg1.cat_sprnt("\t%s\n", name.c_str()); logmsg(DEBUG, info_msg1.c_str()); func_t *pfn = get_func(addr); if (!pfn) continue; hexrays_failure_t hf; cfuncptr_t cfunc = decompile(pfn, &hf); if (cfunc != NULL) { qstring var_name; info_msg.clear(); if (find_var(cfunc, (*vtbl_iter).vtbl_name, var_name)) { info_msg.cat_sprnt(" : %s\n", var_name.c_str()); logmsg(DEBUG, info_msg.c_str()); qstring sub_type_name = type_name; sub_type_name.cat_sprnt("_%d", struct_subno); struct_subno++; if (reconstruct_type(cfunc, var_name, sub_type_name)) { if (check_subtype((*vtbl_iter), sub_type_name)) { types_to_merge.push_back(sub_type_name); } } } else { info_msg.cat_sprnt(" : none\n"); logmsg(DEBUG, info_msg.c_str()); } } } struct_no++; merge_types(types_to_merge, type_name); dump_type_info(file_id, (*vtbl_iter), type_name, vtbl_map); } qclose(file_id); return true; }
/* * the devxxx.c that calls us handles writing data, it knows best */ int32_t netifwrite(Netif *nif, Chan *c, void *a, int32_t n) { Proc *up = externup(); Netfile *f; int type, mtu; char *p, buf[64]; uint8_t binaddr[Nmaxaddr]; if(NETTYPE(c->qid.path) != Nctlqid) error(Eperm); if(n >= sizeof(buf)) n = sizeof(buf)-1; memmove(buf, a, n); buf[n] = 0; if(waserror()){ qunlock(&nif->q); nexterror(); } qlock(&nif->q); f = nif->f[NETID(c->qid.path)]; if((p = matchtoken(buf, "connect")) != 0){ qclose(f->iq); type = atoi(p); if(typeinuse(nif, type)) error(Einuse); f->type = type; if(f->type < 0) nif->all++; qreopen(f->iq); } else if(matchtoken(buf, "promiscuous")){ if(f->prom == 0){ if(nif->prom == 0 && nif->promiscuous != nil) nif->promiscuous(nif->arg, 1); f->prom = 1; nif->prom++; } } else if((p = matchtoken(buf, "scanbs")) != 0){ /* scan for base stations */ if(f->scan == 0){ type = atoi(p); if(type < 5) type = 5; if(nif->scanbs != nil) nif->scanbs(nif->arg, type); f->scan = type; nif->_scan++; } } else if((p = matchtoken(buf, "mtu")) != 0){ /* poor planning. */ if(!iseve()) error(Eperm); mtu = atoi(p); /* zero resets default. */ if(mtu != 0) if(mtu < nif->minmtu || mtu > nif->maxmtu) error(Ebadarg); if(nif->hwmtu) nif->mtu = nif->hwmtu(nif->arg, mtu); else nif->mtu = mtu; } else if(matchtoken(buf, "l2bridge")){ f->bridge |= 2; } else if(matchtoken(buf, "bridge")){ f->bridge |= 1; } else if(matchtoken(buf, "headersonly")){ f->headersonly = 1; } else if((p = matchtoken(buf, "addmulti")) != 0){ if(parseaddr(binaddr, p, nif->alen) < 0) error("bad address"); p = netmulti(nif, f, binaddr, 1); if(p) error(p); } else if((p = matchtoken(buf, "remmulti")) != 0){ if(parseaddr(binaddr, p, nif->alen) < 0) error("bad address"); p = netmulti(nif, f, binaddr, 0); if(p) error(p); } else n = -1; qunlock(&nif->q); poperror(); return n; }
/* * be extremely careful when calling this, * as there is no reference accounting */ void qfree(Queue *q) { qclose(q); free(q); }
void lqclose(void *qp){ if(NULL != qp){ qclose(((lqtype *)qp)->queue); free((lqtype *)qp); } }