static int run(void) { int i, ret = 0; buf = malloc(!custom ? test_size[TEST_CNT - 1].size : transfer_size); if (!buf) { perror("malloc"); return -1; } if (!dst_addr) { ret = server_listen(); if (ret) goto free; } printf("%-10s%-8s%-8s%-8s%-8s%8s %10s%13s\n", "name", "bytes", "xfers", "iters", "total", "time", "Gb/sec", "usec/xfer"); if (!custom) { optimization = opt_latency; ret = dst_addr ? client_connect() : server_connect(); if (ret) goto free; for (i = 0; i < TEST_CNT; i++) { if (test_size[i].option > size_option) continue; init_latency_test(test_size[i].size); run_test(); } rshutdown(rs, SHUT_RDWR); rclose(rs); optimization = opt_bandwidth; ret = dst_addr ? client_connect() : server_connect(); if (ret) goto free; for (i = 0; i < TEST_CNT; i++) { if (test_size[i].option > size_option) continue; init_bandwidth_test(test_size[i].size); run_test(); } } else { ret = dst_addr ? client_connect() : server_connect(); if (ret) goto free; ret = run_test(); } rshutdown(rs, SHUT_RDWR); rclose(rs); free: free(buf); return ret; }
int close(int socket) { struct fd_info *fdi; int ret; init_preload(); fdi = idm_lookup(&idm, socket); if (!fdi) return real.close(socket); if (fdi->dupfd != -1) { ret = close(fdi->dupfd); if (ret) return ret; } if (atomic_dec(&fdi->refcnt)) return 0; idm_clear(&idm, socket); real.close(socket); ret = (fdi->type == fd_rsocket) ? rclose(fdi->fd) : real.close(fdi->fd); free(fdi); return ret; }
/* -------------------------------------------------------------------------*/ int main(int argc, char **argv) { R_LOG_INFO("debug version") rpreinit(); rstyle_preinit(); rargs( argc, argv ); rdisplay_init(); rdisplay_config(); rstyle_config(); raudio_config(); rplaylist_init(); rplaylist_config(); rpanels(); raudio_init(); raudio_playlist_populate(); /*rattr( alloc_disable ) = 1; */ /* disable allocation */ rdisplay_mainLoop(); raudio_close( ); rclose(); return 0; }
/* ------------------------------------------------------------- ** ** Central select bit. Deals with data connection ** forwarding/listening, and quits on ctrl connection close. Once ** there is a complete line read from one of the control connctions ** specified in "which" (GET_SRVR, GET_CTRL, or GET_SRVR|GET_CTRL) we ** return. ** ** The line read into the control connection buffer on function return ** contains a newline (\n), and is NULL terminated at some point ** beyond that. No other checking has been done on it. ** ** Return value is one of GET_SRVR, GET_CTRL or GET_SRVR|GET_CTRL. ** ------------------------------------------------------------- */ int get_control_line(int which) { int ret = 0, i; fd_set reads, writes; do { i = setup_fds(&reads, &writes); alarm(config.timeout); if(select(i + 1, &reads, &writes, NULL, NULL) == -1) { if(errno == EINTR) continue; debug_perr("select"); die(0, NULL, 0, NULL, -1); } do_dataforward(&reads, &writes); if(FD_ISSET(info->client_control.fd, &reads)) { i = sstr_append_read(info->client_control.fd, info->client_control.buf, 0); if(i == 0) die(INFO, "Client closed connection", 0, NULL, 0); if(i < 0) die(ATTACK, "Client flooding control connection", 421, "You're sending rubbish. Goodbye", -1); if(sstr_hasline(info->client_control.buf)) ret |= GET_CLNT; } if(info->server_control.fd != -1 && FD_ISSET(info->server_control.fd, &reads)) { i = read_srvrctrl_data(); if(i == 0) { if(!cache_transferring()) die(ERROR, "Server closed the control connection", 0, NULL, 0); else { rclose(&info->server_control.fd); write_log(INFO, "Server closed connection. Keeping going until cache done"); } } if(i < 0) die(ATTACK, "Server flooding the control connection", 421, "Server is sending rubbish." "Closing connection", -1); if(sstr_hasline(info->server_control.buf)) ret |= GET_SRVR; } } while(!(ret & which)); return (ret); }
static int client_connect(void) { struct addrinfo *res; struct pollfd fds; int ret, err; socklen_t len; ret = getaddrinfo(dst_addr, port, NULL, &res); if (ret) { perror("getaddrinfo"); return ret; } rs = rsocket(res->ai_family, res->ai_socktype, res->ai_protocol); if (rs < 0) { perror("rsocket"); ret = rs; goto free; } set_options(rs); /* TODO: bind client to src_addr */ ret = rconnect(rs, res->ai_addr, res->ai_addrlen); if (ret && (errno != EINPROGRESS)) { perror("rconnect"); goto close; } if (ret && (errno == EINPROGRESS)) { fds.fd = rs; fds.events = POLLOUT; ret = do_poll(&fds, poll_timeout); if (ret) goto close; len = sizeof err; ret = rgetsockopt(rs, SOL_SOCKET, SO_ERROR, &err, &len); if (ret) goto close; if (err) { ret = -1; errno = err; perror("async rconnect"); } } close: if (ret) rclose(rs); free: freeaddrinfo(res); return ret; }
CAMLprim value ordma_rclose(value fd) { int ret; int fd_ = Int_val(fd); ORDMA_LOG("ordma_rclose(%i)", fd_); caml_enter_blocking_section(); ret = rclose(fd_); caml_leave_blocking_section(); ORDMA_LOG("ordma_rclose(%i),ret=%i",fd_,ret); if (ret == -1) { uerror("close", Nothing); } return Val_unit; }
static int server_listen(void) { struct addrinfo hints, *res; int val, ret; memset(&hints, 0, sizeof hints); hints.ai_flags = AI_PASSIVE; ret = getaddrinfo(src_addr, port, &hints, &res); if (ret) { perror("getaddrinfo"); return ret; } lrs = rsocket(res->ai_family, res->ai_socktype, res->ai_protocol); if (lrs < 0) { perror("rsocket"); ret = lrs; goto free; } val = 1; ret = rsetsockopt(lrs, SOL_SOCKET, SO_REUSEADDR, &val, sizeof val); if (ret) { perror("rsetsockopt SO_REUSEADDR"); goto close; } ret = rbind(lrs, res->ai_addr, res->ai_addrlen); if (ret) { perror("rbind"); goto close; } ret = rlisten(lrs, 1); if (ret) perror("rlisten"); close: if (ret) rclose(lrs); free: freeaddrinfo(res); return ret; }
/* * We can't fork RDMA connections and pass them from the parent to the child * process. Instead, we need to establish the RDMA connection after calling * fork. To do this, we delay establishing the RDMA connection until we try * to send/receive on the server side. */ static void fork_active(int socket) { struct sockaddr_storage addr; int sfd, dfd, ret; socklen_t len; uint32_t msg; long flags; sfd = fd_getd(socket); flags = real.fcntl(sfd, F_GETFL); real.fcntl(sfd, F_SETFL, 0); ret = real.recv(sfd, &msg, sizeof msg, MSG_PEEK); real.fcntl(sfd, F_SETFL, flags); if ((ret != sizeof msg) || msg) goto err1; len = sizeof addr; ret = real.getpeername(sfd, (struct sockaddr *) &addr, &len); if (ret) goto err1; dfd = rsocket(addr.ss_family, SOCK_STREAM, 0); if (dfd < 0) goto err1; ret = rconnect(dfd, (struct sockaddr *) &addr, len); if (ret) goto err2; set_rsocket_options(dfd); copysockopts(dfd, sfd, &rs, &real); real.shutdown(sfd, SHUT_RDWR); real.close(sfd); fd_store(socket, dfd, fd_rsocket, fd_ready); return; err2: rclose(dfd); err1: fd_store(socket, sfd, fd_normal, fd_ready); }
int connect(int socket, const struct sockaddr *addr, socklen_t addrlen) { int fd, ret; if (fd_get(socket, &fd) == fd_rsocket) { ret = rconnect(fd, addr, addrlen); if (!ret || errno == EINPROGRESS) return ret; ret = transpose_socket(socket, fd_normal); if (ret < 0) return ret; rclose(fd); fd = ret; } else if (fd_gets(socket) == fd_fork) { fd_store(socket, fd, fd_normal, fd_fork_active); } return real.connect(fd, addr, addrlen); }
/* * The server will start listening for the new connection, then send a * message to the active side when the listen is ready. This does leave * fork unsupported in the following case: the server is nonblocking and * calls select/poll waiting to receive data from the client. */ static void fork_passive(int socket) { struct sockaddr_in6 sin6; sem_t *sem; int lfd, sfd, dfd, ret, param; socklen_t len; uint32_t msg; sfd = fd_getd(socket); len = sizeof sin6; ret = real.getsockname(sfd, (struct sockaddr *) &sin6, &len); if (ret) goto out; sin6.sin6_flowinfo = sin6.sin6_scope_id = 0; memset(&sin6.sin6_addr, 0, sizeof sin6.sin6_addr); sem = sem_open("/rsocket_fork", O_CREAT | O_RDWR, S_IRWXU | S_IRWXG, 1); if (sem == SEM_FAILED) { ret = -1; goto out; } lfd = rsocket(sin6.sin6_family, SOCK_STREAM, 0); if (lfd < 0) { ret = lfd; goto sclose; } param = 1; rsetsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, ¶m, sizeof param); sem_wait(sem); ret = rbind(lfd, (struct sockaddr *) &sin6, sizeof sin6); if (ret) goto lclose; ret = rlisten(lfd, 1); if (ret) goto lclose; msg = 0; len = real.write(sfd, &msg, sizeof msg); if (len != sizeof msg) goto lclose; dfd = raccept(lfd, NULL, NULL); if (dfd < 0) { ret = dfd; goto lclose; } set_rsocket_options(dfd); copysockopts(dfd, sfd, &rs, &real); real.shutdown(sfd, SHUT_RDWR); real.close(sfd); fd_store(socket, dfd, fd_rsocket, fd_ready); lclose: rclose(lfd); sem_post(sem); sclose: sem_close(sem); out: if (ret) fd_store(socket, sfd, fd_normal, fd_ready); }
void rfServ_(int acceptSock) { static char fname[] = "rfServ_()"; struct LSFHeader msgHdr; struct LSFHeader buf; struct sockaddr_in from; socklen_t fromLen = sizeof(from); int sock; XDR xdrs; sock = accept(acceptSock, (struct sockaddr *)&from, &fromLen); if (sock < 0) { ls_errlog(stderr, I18N_FUNC_FAIL_MM, fname, "readDecodeHdr_"); closesocket(acceptSock); return; } xdrmem_create(&xdrs, (char *) &buf, sizeof(buf), XDR_DECODE); for (;;) { XDR_SETPOS(&xdrs, 0); if (readDecodeHdr_(sock, (char *)&buf, SOCK_READ_FIX, &xdrs, &msgHdr) < 0) { ls_errlog(stderr, I18N_FUNC_FAIL_MM, fname, "readDecodeHdr_"); closesocket(sock); xdr_destroy(&xdrs); return; } switch (msgHdr.opCode) { case RF_OPEN: ropen(sock, &msgHdr); break; case RF_CLOSE: rclose(sock, &msgHdr); break; case RF_WRITE: rwrite(sock, &msgHdr); break; case RF_READ: rread(sock, &msgHdr); break; case RF_STAT: rstat(sock, &msgHdr); break; case RF_GETMNTHOST: rgetmnthost(sock, &msgHdr); break; case RF_FSTAT: rfstat(sock, &msgHdr); break; case RF_LSEEK: rlseek(sock, &msgHdr); break; case RF_UNLINK: runlink(sock, &msgHdr); break; case RF_TERMINATE: closesocket(sock); return; default: ls_errlog(stderr, _i18n_msg_get(ls_catd, NL_SETN, 602, "%s: Unknown opcode %d"), fname, msgHdr.opCode); xdr_destroy(&xdrs); break; } } }
int gcrepo(int LotNr, char *subname) { int i; struct ReposetoryHeaderFormat ReposetoryHeader; char htmlbuffer[524288]; char imagebuffer[524288]; char *acl_allow; char *acl_deny; char *url, *attributes; unsigned long int raddress; char path[1024]; char path2[1024]; char path3[1024]; FILE *FNREPO; struct reformat *re; int keept = 0; int gced = 0; container *attrkeys = ropen(); if((re = reopen(LotNr, sizeof(struct DocumentIndexFormat), "DocumentIndex", subname, RE_HAVE_4_BYTES_VERSION_PREFIX|RE_COPYONCLOSE)) == NULL) { perror("reopen DocumentIndex"); return 0; } if ( (FNREPO = lotOpenFileNoCasheByLotNr(LotNr,"reposetory","rb", 's',subname)) == NULL) { #ifdef DEBUG printf("lot dont have a reposetory file\n"); #endif return 0; } while (rGetNext_fh(LotNr,&ReposetoryHeader,htmlbuffer,sizeof(htmlbuffer),imagebuffer,&raddress,0,0,subname,&acl_allow,&acl_deny, FNREPO ,&url, &attributes)) { #ifdef DEBUG printf("dokument \"%s\", DocID %u.\n", RE_DocumentIndex(re,ReposetoryHeader.DocID)->Url, ReposetoryHeader.DocID); #endif //printf("%p\n", docindex.RepositoryPointer); if (raddress != RE_DocumentIndex(re,ReposetoryHeader.DocID)->RepositoryPointer) { #ifdef DEBUG printf("Garbage collecting %d at %u. docindex has %u\n", ReposetoryHeader.DocID, raddress,RE_DocumentIndex(re,ReposetoryHeader.DocID)->RepositoryPointer); #endif ++gced; } else { unsigned long int offset; offset = rApendPost(&ReposetoryHeader, htmlbuffer, imagebuffer, subname, acl_allow, acl_deny, "repo.wip", url, attributes, attrkeys); RE_DocumentIndex(re,ReposetoryHeader.DocID)->RepositoryPointer = offset; #ifdef DEBUG printf("Writing DocID: %d\n", ReposetoryHeader.DocID); #endif ++keept; } } fclose(FNREPO); //lokker filen repo.wip //lotCloseFiles(); rclose(attrkeys); printf("keept %i\ngced %i\n",keept,gced); reclose(re); /* And we have a race... */ GetFilPathForLot(path, LotNr, subname); strcpy(path2, path); strcpy(path3, path); strcat(path, "repo.wip"); strcat(path2, "reposetory"); rename(path, path2); strcpy(path, path3); strcat(path, "DocumentIndex.wip"); strcat(path3, "DocumentIndex"); rename(path, path3); #ifdef DI_FILE_CASHE closeDICache(); #endif return 0; }
//stenger ned alle åpne filer int bbdocument_close (container *attrkeys) { rclose(attrkeys); return 1; }
void remove_session(struct cfg *cf, struct rtpp_session *sp) { int i; rtpp_log_write(RTPP_LOG_INFO, sp->log, "RTP stats: %lu in from callee, %lu " "in from caller, %lu relayed, %lu dropped", sp->pcount[0], sp->pcount[1], sp->pcount[2], sp->pcount[3]); rtpp_log_write(RTPP_LOG_INFO, sp->log, "RTCP stats: %lu in from callee, %lu " "in from caller, %lu relayed, %lu dropped", sp->rtcp->pcount[0], sp->rtcp->pcount[1], sp->rtcp->pcount[2], sp->rtcp->pcount[3]); rtpp_log_write(RTPP_LOG_INFO, sp->log, "session on ports %d/%d is cleaned up", sp->ports[0], sp->ports[1]); for (i = 0; i < 2; i++) { if (sp->addr[i] != NULL) free(sp->addr[i]); if (sp->prev_addr[i] != NULL) free(sp->prev_addr[i]); if (sp->rtcp->addr[i] != NULL) free(sp->rtcp->addr[i]); if (sp->rtcp->prev_addr[i] != NULL) free(sp->rtcp->prev_addr[i]); //if(sp->stream[i]->bio != NULL) { // BIO_free(sp->stream[i]->bio); //} if (sp->stream[i] != NULL) { rtpp_dtls_free_stream(sp->stream[i]); } if (sp->rtcp->stream[i] != NULL) { rtpp_dtls_free_stream(sp->rtcp->stream[i]); } if (sp->fds[i] != -1) { close(sp->fds[i]); assert(cf->sessions[sp->sidx[i]] == sp); cf->sessions[sp->sidx[i]] = NULL; assert(cf->pfds[sp->sidx[i]].fd == sp->fds[i]); cf->pfds[sp->sidx[i]].fd = -1; cf->pfds[sp->sidx[i]].events = 0; } if (sp->rtcp->fds[i] != -1) { close(sp->rtcp->fds[i]); assert(cf->sessions[sp->rtcp->sidx[i]] == sp->rtcp); cf->sessions[sp->rtcp->sidx[i]] = NULL; assert(cf->pfds[sp->rtcp->sidx[i]].fd == sp->rtcp->fds[i]); cf->pfds[sp->rtcp->sidx[i]].fd = -1; cf->pfds[sp->rtcp->sidx[i]].events = 0; } if (sp->rrcs[i] != NULL) rclose(sp, sp->rrcs[i], 1); if (sp->rtcp->rrcs[i] != NULL) rclose(sp, sp->rtcp->rrcs[i], 1); if (sp->rtps[i] != NULL) { cf->rtp_servers[sp->sridx] = NULL; rtp_server_free(sp->rtps[i]); } if (sp->codecs[i] != NULL) free(sp->codecs[i]); if (sp->rtcp->codecs[i] != NULL) free(sp->rtcp->codecs[i]); if (sp->bridgeBindAddr[i] != NULL) // VLAN Support (FRN4811) free(sp->bridgeBindAddr[i]); if (sp->ice_u[i] != NULL) { if (sp->ice_u[i]->local_user_name != NULL) free(sp->ice_u[i]->local_user_name); if (sp->ice_u[i]->local_password != NULL) free(sp->ice_u[i]->local_password); if (sp->ice_u[i]->remote_user_name != NULL) free(sp->ice_u[i]->remote_user_name); if (sp->ice_u[i]->remote_password != NULL) free(sp->ice_u[i]->remote_password); free(sp->ice_u[i]); } if (sp->ice_candidate_list[i] != NULL) // ICE remote candidate support delete_ice_candidate(sp, i); if (sp->rtcp->ice_candidate_list[i] != NULL) delete_ice_candidate(sp->rtcp, i); if (sp->transcode) rtp_transcoder_free(&sp->trans[i],cf); if (sp->secure) { rtpp_srtp_free_context(&sp->srtp[i]); rtpp_srtp_free_context(&sp->rtcp->srtp[i]); } rtp_resizer_free(&sp->resizers[i]); }// for rtpp_stun_agent_remove(sp); //Remove stun agent Context. remove_session_frm_active_rsz_lst(sp); rtpp_log_write(RTPP_LOG_INFO, sp->log, "timed resizer lists cleaned up"); if (sp->timeout_data.notify_tag != NULL) free(sp->timeout_data.notify_tag); hash_table_remove(cf, sp); if (sp->call_id != NULL) free(sp->call_id); if (sp->tag != NULL) free(sp->tag); rtpp_log_close(sp->log); free(sp->rtcp); free(sp); cf->sessions_active--; }
void vm_process(VM *vm) { int a, b, opcode; opcode = vm->image[vm->ip]; switch(opcode) { case VM_NOP: break; case VM_LIT: vm->sp++; vm->ip++; TOS = vm->image[vm->ip]; break; case VM_DUP: vm->sp++; vm->data[vm->sp] = NOS; break; case VM_DROP: DROP break; case VM_SWAP: a = TOS; TOS = NOS; NOS = a; break; case VM_PUSH: vm->rsp++; TORS = TOS; DROP break; case VM_POP: vm->sp++; TOS = TORS; vm->rsp--; break; case VM_CALL: vm->ip++; vm->rsp++; TORS = vm->ip; vm->ip = vm->image[vm->ip] - 1; if (vm->ip < 0) vm->ip = IMAGE_SIZE; else { if (vm->image[vm->ip+1] == 0) vm->ip++; if (vm->image[vm->ip+1] == 0) vm->ip++; } break; case VM_JUMP: vm->ip++; vm->ip = vm->image[vm->ip] - 1; if (vm->ip < 0) vm->ip = IMAGE_SIZE; else { if (vm->image[vm->ip+1] == 0) vm->ip++; if (vm->image[vm->ip+1] == 0) vm->ip++; } break; case VM_RETURN: vm->ip = TORS; vm->rsp--; break; case VM_GT_JUMP: vm->ip++; if(NOS > TOS) vm->ip = vm->image[vm->ip] - 1; DROP DROP break; case VM_LT_JUMP: vm->ip++; if(NOS < TOS) vm->ip = vm->image[vm->ip] - 1; DROP DROP break; case VM_NE_JUMP: vm->ip++; if(TOS != NOS) vm->ip = vm->image[vm->ip] - 1; DROP DROP break; case VM_EQ_JUMP: vm->ip++; if(TOS == NOS) vm->ip = vm->image[vm->ip] - 1; DROP DROP break; case VM_FETCH: TOS = vm->image[TOS]; break; case VM_STORE: vm->image[TOS] = NOS; DROP DROP break; case VM_ADD: NOS += TOS; DROP break; case VM_SUB: NOS -= TOS; DROP break; case VM_MUL: NOS *= TOS; DROP break; case VM_DIVMOD: a = TOS; b = NOS; TOS = b / a; NOS = b % a; break; case VM_AND: a = TOS; b = NOS; DROP TOS = a & b; break; case VM_OR: a = TOS; b = NOS; DROP TOS = a | b; break; case VM_XOR: a = TOS; b = NOS; DROP TOS = a ^ b; break; case VM_SHL: a = TOS; b = NOS; DROP TOS = b << a; break; case VM_SHR: a = TOS; b = NOS; DROP TOS = b >>= a; break; case VM_ZERO_EXIT: if (TOS == 0) { DROP vm->ip = TORS; vm->rsp--; } break; case VM_INC: TOS += 1; break; case VM_DEC: TOS -= 1; break; case VM_IN: a = TOS; TOS = vm->ports[a]; vm->ports[a] = 0; break; case VM_OUT: vm->ports[0] = 0; vm->ports[TOS] = NOS; DROP DROP break; case VM_WAIT: if (vm->ports[0] == 1) break; /* Input */ if (vm->ports[0] == 0 && vm->ports[1] == 1) { vm->ports[1] = dev_getch(); vm->ports[0] = 1; } /* Output (character generator) */ if (vm->ports[2] == 1) { dev_putch(TOS); DROP vm->ports[2] = 0; vm->ports[0] = 1; } if (vm->ports[4] != 0) { vm->ports[0] = 1; switch (vm->ports[4]) { case 1: vm_save_image(vm, vm->filename); vm->ports[4] = 0; break; case 2: file_add(vm); vm->ports[4] = 0; break; case -1: vm->ports[4] = file_handle(vm); break; case -2: vm->ports[4] = file_readc(vm); break; case -3: vm->ports[4] = file_writec(vm); break; case -4: vm->ports[4] = file_closehandle(vm); break; case -5: vm->ports[4] = file_getpos(vm); break; case -6: vm->ports[4] = file_seek(vm); break; case -7: vm->ports[4] = file_size(vm); break; default: vm->ports[4] = 0; } } /* Capabilities */ if (vm->ports[5] != 0) { vm->ports[0] = 1; switch(vm->ports[5]) { case -1: vm->ports[5] = IMAGE_SIZE; break; case -2: vm->ports[5] = 0; break; case -3: vm->ports[5] = 0; break; case -4: vm->ports[5] = 0; break; case -5: vm->ports[5] = vm->sp; break; case -6: vm->ports[5] = vm->rsp; break; case -7: vm->ports[5] = 0; break; case -8: vm->ports[5] = time(NULL); break; case -9: vm->ports[5] = 0; vm->ip = IMAGE_SIZE; break; default: vm->ports[5] = 0; } } if (vm->ports[8] != 0) { vm->ports[0] = 1; switch (vm->ports[8]) { case -1: rsocket(vm); vm->ports[8] = 0; break; case -2: rbind(vm); vm->ports[8] = 0; break; case -3: rlisten(vm); vm->ports[8] = 0; break; case -4: raccept(vm); vm->ports[8] = 0; break; case -5: rclose(vm); vm->ports[8] = 0; break; case -6: rsend(vm); vm->ports[8] = 0; break; case -7: rrecv(vm); vm->ports[8] = 0; break; case -8: rconnect(vm); vm->ports[8] = 0; break; default: vm->ports[8] = 0; } vm->ports[8] = 0; } break; default: vm->rsp++; TORS = vm->ip; vm->ip = vm->image[vm->ip] - 1; if (vm->ip < 0) vm->ip = IMAGE_SIZE; else { if (vm->image[vm->ip+1] == 0) vm->ip++; if (vm->image[vm->ip+1] == 0) vm->ip++; } break; } vm->ports[3] = 1; }
void remove_session(struct cfg *cf, struct rtpp_session *sp) { int i; rtpp_log_write(RTPP_LOG_INFO, sp->log, "RTP stats: %lu in from callee, %lu " "in from caller, %lu relayed, %lu dropped", sp->pcount[0], sp->pcount[1], sp->pcount[2], sp->pcount[3]); rtpp_log_write(RTPP_LOG_INFO, sp->log, "RTCP stats: %lu in from callee, %lu " "in from caller, %lu relayed, %lu dropped", sp->rtcp->pcount[0], sp->rtcp->pcount[1], sp->rtcp->pcount[2], sp->rtcp->pcount[3]); rtpp_log_write(RTPP_LOG_INFO, sp->log, "session on ports %d/%d is cleaned up", sp->ports[0], sp->ports[1]); for (i = 0; i < 2; i++) { if (sp->addr[i] != NULL) free(sp->addr[i]); if (sp->prev_addr[i] != NULL) free(sp->prev_addr[i]); if (sp->rtcp->addr[i] != NULL) free(sp->rtcp->addr[i]); if (sp->rtcp->prev_addr[i] != NULL) free(sp->rtcp->prev_addr[i]); if (sp->fds[i] != -1) { close(sp->fds[i]); assert(cf->sessions[sp->sidx[i]] == sp); cf->sessions[sp->sidx[i]] = NULL; assert(cf->pfds[sp->sidx[i]].fd == sp->fds[i]); cf->pfds[sp->sidx[i]].fd = -1; cf->pfds[sp->sidx[i]].events = 0; } if (sp->rtcp->fds[i] != -1) { close(sp->rtcp->fds[i]); assert(cf->sessions[sp->rtcp->sidx[i]] == sp->rtcp); cf->sessions[sp->rtcp->sidx[i]] = NULL; assert(cf->pfds[sp->rtcp->sidx[i]].fd == sp->rtcp->fds[i]); cf->pfds[sp->rtcp->sidx[i]].fd = -1; cf->pfds[sp->rtcp->sidx[i]].events = 0; } if (sp->rrcs[i] != NULL) rclose(sp, sp->rrcs[i], 1); if (sp->rtcp->rrcs[i] != NULL) rclose(sp, sp->rtcp->rrcs[i], 1); if (sp->rtps[i] != NULL) { cf->rtp_servers[sp->sridx] = NULL; rtp_server_free(sp->rtps[i]); } if (sp->codecs[i] != NULL) free(sp->codecs[i]); if (sp->rtcp->codecs[i] != NULL) free(sp->rtcp->codecs[i]); } if (sp->timeout_data.notify_tag != NULL) free(sp->timeout_data.notify_tag); hash_table_remove(cf, sp); if (sp->call_id != NULL) free(sp->call_id); if (sp->tag != NULL) free(sp->tag); rtpp_log_close(sp->log); free(sp->rtcp); rtp_resizer_free(&sp->resizers[0]); rtp_resizer_free(&sp->resizers[1]); free(sp); cf->sessions_active--; }
void remove_session(struct cfg *cf, struct rtpp_session *sp) { int i; double session_time; session_time = getdtime() - sp->init_ts; /* Make sure structure is properly locked */ assert(pthread_mutex_islocked(&cf->glock) == 1); assert(pthread_mutex_islocked(&cf->sessinfo.lock) == 1); rtpp_log_write(RTPP_LOG_INFO, sp->log, "RTP stats: %lu in from callee, %lu " "in from caller, %lu relayed, %lu dropped", sp->pcount[0], sp->pcount[1], sp->pcount[2], sp->pcount[3]); if (sp->pcount[0] == 0 && sp->pcount[1] == 0) { CALL_METHOD(cf->stable->rtpp_stats, updatebyname, "nsess_nortp", 1); } else if (sp->pcount[0] == 0 || sp->pcount[1] == 0) { CALL_METHOD(cf->stable->rtpp_stats, updatebyname, "nsess_owrtp", 1); } rtpp_log_write(RTPP_LOG_INFO, sp->log, "RTCP stats: %lu in from callee, %lu " "in from caller, %lu relayed, %lu dropped", sp->rtcp->pcount[0], sp->rtcp->pcount[1], sp->rtcp->pcount[2], sp->rtcp->pcount[3]); if (sp->rtcp->pcount[0] == 0 && sp->rtcp->pcount[1] == 0) { CALL_METHOD(cf->stable->rtpp_stats, updatebyname, "nsess_nortcp", 1); } else if (sp->rtcp->pcount[0] == 0 || sp->rtcp->pcount[1] == 0) { CALL_METHOD(cf->stable->rtpp_stats, updatebyname, "nsess_owrtcp", 1); } rtpp_log_write(RTPP_LOG_INFO, sp->log, "session on ports %d/%d is cleaned up", sp->ports[0], sp->ports[1]); for (i = 0; i < 2; i++) { if (sp->addr[i] != NULL) free(sp->addr[i]); if (sp->prev_addr[i] != NULL) free(sp->prev_addr[i]); if (sp->rtcp->addr[i] != NULL) free(sp->rtcp->addr[i]); if (sp->rtcp->prev_addr[i] != NULL) free(sp->rtcp->prev_addr[i]); if (sp->fds[i] != -1) { shutdown(sp->fds[i], SHUT_RDWR); close(sp->fds[i]); assert(cf->sessinfo.sessions[sp->sidx[i]] == sp); cf->sessinfo.sessions[sp->sidx[i]] = NULL; assert(cf->sessinfo.pfds_rtp[sp->sidx[i]].fd == sp->fds[i]); cf->sessinfo.pfds_rtp[sp->sidx[i]].fd = -1; cf->sessinfo.pfds_rtp[sp->sidx[i]].events = 0; } if (sp->rtcp->fds[i] != -1) { shutdown(sp->rtcp->fds[i], SHUT_RDWR); close(sp->rtcp->fds[i]); assert(cf->sessinfo.pfds_rtcp[sp->rtcp->sidx[i]].fd == sp->rtcp->fds[i]); cf->sessinfo.pfds_rtcp[sp->rtcp->sidx[i]].fd = -1; cf->sessinfo.pfds_rtcp[sp->rtcp->sidx[i]].events = 0; } if (sp->rrcs[i] != NULL) { rclose(sp, sp->rrcs[i], 1); if (sp->record_single_file != 0) { sp->rtcp->rrcs[i] = NULL; sp->rrcs[NOT(i)] = NULL; sp->rtcp->rrcs[NOT(i)] = NULL; } } if (sp->rtcp->rrcs[i] != NULL) rclose(sp, sp->rtcp->rrcs[i], 1); if (sp->rtps[i] != NULL) { cf->rtp_servers[sp->sridx] = NULL; rtp_server_free(sp->rtps[i]); } if (sp->codecs[i] != NULL) free(sp->codecs[i]); if (sp->rtcp->codecs[i] != NULL) free(sp->rtcp->codecs[i]); if (sp->resizers[i] != NULL) rtp_resizer_free(sp->resizers[i]); } if (sp->timeout_data.notify_tag != NULL) free(sp->timeout_data.notify_tag); if (sp->hte != NULL) CALL_METHOD(cf->stable->sessions_ht, remove, sp->call_id, sp->hte); if (sp->call_id != NULL) free(sp->call_id); if (sp->tag != NULL) free(sp->tag); if (sp->tag_nomedianum != NULL) free(sp->tag_nomedianum); rtpp_log_close(sp->log); free(sp->rtcp); free(sp); cf->sessions_active--; CALL_METHOD(cf->stable->rtpp_stats, updatebyname, "nsess_destroyed", 1); CALL_METHOD(cf->stable->rtpp_stats, updatebyname_d, "total_duration", session_time); }