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);
}
