FSINFO3res *nfsproc3_fsinfo_3_svc(FSINFO3args * argp, struct svc_req * rqstp)
{
static FSINFO3res result;
char *path;
unsigned int maxdata;
if (get_socket_type(rqstp) == SOCK_STREAM)
maxdata = NFS_MAXDATA_TCP;
else
maxdata = NFS_MAXDATA_UDP;
PREP(path, argp->fsroot);
result.FSINFO3res_u.resok.obj_attributes = get_post_cached(rqstp);
result.status = NFS3_OK;
result.FSINFO3res_u.resok.rtmax = maxdata;
result.FSINFO3res_u.resok.rtpref = maxdata;
result.FSINFO3res_u.resok.rtmult = 4096;
result.FSINFO3res_u.resok.wtmax = maxdata;
result.FSINFO3res_u.resok.wtpref = maxdata;
result.FSINFO3res_u.resok.wtmult = 4096;
result.FSINFO3res_u.resok.dtpref = 4096;
result.FSINFO3res_u.resok.maxfilesize = ~0ULL;
result.FSINFO3res_u.resok.time_delta.seconds = backend_time_delta_seconds;
result.FSINFO3res_u.resok.time_delta.nseconds = 0;
result.FSINFO3res_u.resok.properties = backend_fsinfo_properties;
return &result;
}
int reopen_socket_with_other_family(int s, int family)
{
int type, protocol, result, saved_fd;
result = 0;
// duplicate the file descriptor
saved_fd = dup(s);
// record the type, protocol and fd of the existing socket
type = get_socket_type(s);
protocol = get_socket_protocol(s);
// close the socket - this way the fd integer should be available for our new socket
// and the calling program will not notice that the socket is not the same
original_close(s);
// create an IPv6 socket on the same file descriptor s
if (create_socket_on_specified_free_fd(s, family, type, protocol) == -1)
{ // failed ! recreate file descriptor previously closed
dup2(saved_fd, s);
result = -1;
}
else
{
report_socket_options(saved_fd, s);
}
// saved_fd is not useful anymore
original_close(saved_fd);
return result;
}
void on_recv(int fd, void *arg)
{
char buf[128] = {0};
int sock_type = get_socket_type(fd);
int proto_type = get_socket_protocol(fd);
switch (sock_type) {
case SOCK_STREAM:
if (proto_type == IPPROTO_TCP)
socket_recv(fd, buf, sizeof(buf));
else if (proto_type == IPPROTO_SCTP) ;
else return;
break;
case SOCK_DGRAM:
socket_addr_recvfrom(fd, buf, sizeof(buf),
(void *)&((struct socket_impl *)arg)->addr.in_addr);
break;
default:
return;
break;
}
printf("recv from %s: %s\n",
inet_ntoa(((struct socket_impl *)arg)->addr.in_addr.sin_addr),
buf);
}
int
fricas_accept_connection(Sock *sock)
{
int client;
for(client=0; client<MaxClients && clients[client].socket != 0; client++);
if (client == MaxClients) {
printf("Ran out of client Sock structures\n");
return -1;
}
clients[client].socket = accept(sock->socket, 0, 0);
if (is_invalid_socket(&clients[client])) {
perror("accept_connection");
clients[client].socket = 0;
return -1;
}
FD_SET(clients[client].socket, &socket_mask);
get_socket_type(clients+client);
return clients[client].purpose;
}
READ3res *nfsproc3_read_3_svc(READ3args * argp, struct svc_req * rqstp)
{
static READ3res result;
char *path;
int fd, res;
static char buf[NFS_MAXDATA_TCP + 1];
unsigned int maxdata;
if (get_socket_type(rqstp) == SOCK_STREAM)
maxdata = NFS_MAXDATA_TCP;
else
maxdata = NFS_MAXDATA_UDP;
PREP(path, argp->file);
result.status = is_reg();
/* handle reading of executables */
read_executable(rqstp, st_cache);
/* handle read of owned files */
read_by_owner(rqstp, st_cache);
/* if bigger than rtmax, truncate length */
if (argp->count > maxdata)
argp->count = maxdata;
if (result.status == NFS3_OK) {
fd = fd_open(path, argp->file, UNFS3_FD_READ, TRUE);
if (fd != -1) {
/* read one more to check for eof */
res = backend_pread(fd, buf, argp->count + 1, (off64_t)argp->offset);
/* eof if we could not read one more */
result.READ3res_u.resok.eof = (res <= (int64) argp->count);
/* close for real when hitting eof */
if (result.READ3res_u.resok.eof)
fd_close(fd, UNFS3_FD_READ, FD_CLOSE_REAL);
else {
fd_close(fd, UNFS3_FD_READ, FD_CLOSE_VIRT);
res--;
}
if (res >= 0) {
result.READ3res_u.resok.count = res;
result.READ3res_u.resok.data.data_len = res;
result.READ3res_u.resok.data.data_val = buf;
} else {
/* error during read() */
/* EINVAL means unreadable object */
if (errno == EINVAL)
result.status = NFS3ERR_INVAL;
else
result.status = NFS3ERR_IO;
}
} else
/* opening for read failed */
result.status = read_err();
}
/* overlaps with resfail */
result.READ3res_u.resok.file_attributes = get_post_stat(path, rqstp);
return &result;
}
static int clnet_connect(uint16_t clnet_remote_port, const char *remote_address,
const unsigned char* ifname, const char *local_address, int verbose,
app_ur_conn_info *clnet_info) {
ioa_addr local_addr;
evutil_socket_t clnet_fd;
int connect_err;
int connect_cycle = 0;
ioa_addr remote_addr;
start_socket:
clnet_fd = -1;
connect_err = 0;
ns_bzero(&remote_addr, sizeof(ioa_addr));
if (make_ioa_addr((const u08bits*) remote_address, clnet_remote_port,
&remote_addr) < 0)
return -1;
ns_bzero(&local_addr, sizeof(ioa_addr));
clnet_fd = socket(remote_addr.ss.sa_family,
use_sctp ? SCTP_CLIENT_STREAM_SOCKET_TYPE : (use_tcp ? CLIENT_STREAM_SOCKET_TYPE : CLIENT_DGRAM_SOCKET_TYPE),
use_sctp ? SCTP_CLIENT_STREAM_SOCKET_PROTOCOL : (use_tcp ? CLIENT_STREAM_SOCKET_PROTOCOL : CLIENT_DGRAM_SOCKET_PROTOCOL));
if (clnet_fd < 0) {
perror("socket");
exit(-1);
}
if (sock_bind_to_device(clnet_fd, ifname) < 0) {
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO,
"Cannot bind client socket to device %s\n", ifname);
}
set_sock_buf_size(clnet_fd, UR_CLIENT_SOCK_BUF_SIZE);
set_raw_socket_tos(clnet_fd, remote_addr.ss.sa_family, 0x22);
set_raw_socket_ttl(clnet_fd, remote_addr.ss.sa_family, 47);
if(clnet_info->is_peer && (*local_address==0)) {
if(remote_addr.ss.sa_family == AF_INET6) {
if (make_ioa_addr((const u08bits*) "::1", 0, &local_addr) < 0) {
return -1;
}
} else {
if (make_ioa_addr((const u08bits*) "127.0.0.1", 0, &local_addr) < 0) {
return -1;
}
}
addr_bind(clnet_fd, &local_addr, 0, 1, get_socket_type());
} else if (strlen(local_address) > 0) {
if (make_ioa_addr((const u08bits*) local_address, 0,
&local_addr) < 0)
return -1;
addr_bind(clnet_fd, &local_addr,0,1,get_socket_type());
}
if(clnet_info->is_peer) {
;
} else if(socket_connect(clnet_fd, &remote_addr, &connect_err)>0)
goto start_socket;
if (clnet_info) {
addr_cpy(&(clnet_info->remote_addr), &remote_addr);
addr_cpy(&(clnet_info->local_addr), &local_addr);
clnet_info->fd = clnet_fd;
addr_get_from_sock(clnet_fd, &(clnet_info->local_addr));
STRCPY(clnet_info->lsaddr,local_address);
STRCPY(clnet_info->rsaddr,remote_address);
STRCPY(clnet_info->ifname,(const char*)ifname);
}
if (use_secure) {
int try_again = 0;
clnet_info->ssl = tls_connect(clnet_info->fd, &remote_addr,&try_again,connect_cycle++);
if (!clnet_info->ssl) {
if(try_again) {
goto start_socket;
}
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "%s: cannot SSL connect to remote addr\n", __FUNCTION__);
exit(-1);
}
}
if(verbose && clnet_info) {
addr_debug_print(verbose, &(clnet_info->local_addr), "Connected from");
addr_debug_print(verbose, &remote_addr, "Connected to");
}
if(!dos) usleep(500);
return 0;
}
static int parse_attribute_candidate(struct sdp_attribute *output) {
PARSE_DECL;
char *ep;
struct attribute_candidate *c;
output->attr = ATTR_CANDIDATE;
c = &output->u.candidate;
PARSE_INIT;
EXTRACT_TOKEN(u.candidate.cand_parsed.foundation);
EXTRACT_TOKEN(u.candidate.component_str);
EXTRACT_TOKEN(u.candidate.transport_str);
EXTRACT_TOKEN(u.candidate.priority_str);
EXTRACT_TOKEN(u.candidate.address_str);
EXTRACT_TOKEN(u.candidate.port_str);
EXTRACT_TOKEN(u.candidate.typ_str);
EXTRACT_TOKEN(u.candidate.type_str);
c->cand_parsed.component_id = strtoul(c->component_str.s, &ep, 10);
if (ep == c->component_str.s)
return -1;
c->cand_parsed.transport = get_socket_type(&c->transport_str);
if (!c->cand_parsed.transport)
return 0;
c->cand_parsed.priority = strtoul(c->priority_str.s, &ep, 10);
if (ep == c->priority_str.s)
return -1;
if (__parse_address(&c->cand_parsed.endpoint.address, NULL, NULL, &c->address_str))
return 0;
c->cand_parsed.endpoint.port = strtoul(c->port_str.s, &ep, 10);
if (ep == c->port_str.s)
return -1;
if (str_cmp(&c->typ_str, "typ"))
return -1;
c->cand_parsed.type = ice_candidate_type(&c->type_str);
if (!c->cand_parsed.type)
return 0;
if (!ice_has_related(c->cand_parsed.type))
goto done;
EXTRACT_TOKEN(u.candidate.raddr_str);
EXTRACT_TOKEN(u.candidate.related_address_str);
EXTRACT_TOKEN(u.candidate.rport_str);
EXTRACT_TOKEN(u.candidate.related_port_str);
if (str_cmp(&c->raddr_str, "raddr"))
return -1;
if (str_cmp(&c->rport_str, "rport"))
return -1;
if (__parse_address(&c->cand_parsed.related.address, NULL, NULL, &c->related_address_str))
return 0;
c->cand_parsed.related.port = strtoul(c->related_port_str.s, &ep, 10);
if (ep == c->related_port_str.s)
return -1;
done:
c->parsed = 1;
return 0;
}
