//
// Constructor
//
InetSocketAddress::InetSocketAddress(const char* hostname, in_port_t port, bool ipv6)
throw(IllegalArgumentException)
{
_ipv6 = ipv6;
// Inicializa el puerto
init_port(port);
// Intenta resolver la direccion IP de "hostname"
InetAddress* inaddr = NULL;
try
{
inaddr = InetAddress::getByName(hostname);
}
catch(...)
{
_resolved = false;
init_addr(NULL);
return;
}
// Inicializa la direccion IP y libera el objeto InetAddress
init_addr(inaddr);
delete inaddr;
}
int main(int argc, char **argv)
{
addr_t addr;
double timeout = 5.0;
int sock;
if (argc < 2) {
printf("Usage: connect host:port [timeout_in_seconds]\n");
return 1;
}
if (argc > 2) {
timeout = atof(argv[2]);
if (timeout <= 0) {
timeout = 5.0;
printf("Warning: using timeout %gs\n", timeout);
}
}
printf("Resolving...\n");
if (init_addr(&addr, argv[1]) != 0)
perror_fatal("init_addr(%s)", argv[1]);
sock = socket(addr.name.sa_family, SOCK_STREAM, 0);
if (sock == -1)
perror_fatal("socket");
printf("Connecting...\n");
if (nonblock_connect(sock, &addr.name, addr.namelen, timeout * 1000) == -1)
perror_fatal("connect(%s)", addr.a_addr);
else
printf("Success!\n");
return 0;
}
void init (int argc,char *argv[])
{
struct lac *lac;
init_args (argc,argv);
rand_source = 0;
init_addr ();
if (init_config ())
{
log (LOG_CRIT, "%s: Unable to load config file\n", __FUNCTION__);
exit (1);
}
if (uname (&uts))
{
log (LOG_CRIT, "%s : Unable to determine host system\n",
__FUNCTION__);
exit (1);
}
init_tunnel_list (&tunnels);
if (init_network ())
exit (1);
if (gconfig.daemon)
daemonize ();
signal (SIGTERM, &death_handler);
signal (SIGINT, &death_handler);
signal (SIGCHLD, &child_handler);
signal (SIGUSR1, &status_handler);
signal (SIGHUP, &null_handler);
init_scheduler ();
mkfifo (CONTROL_PIPE, 0600);
control_fd = open (CONTROL_PIPE, O_RDONLY | O_NONBLOCK, 0600);
if (control_fd < 0)
{
log (LOG_CRIT, "%s: Unable to open " CONTROL_PIPE " for reading.",
__FUNCTION__);
exit (1);
}
log (LOG_LOG, "l2tpd version " SERVER_VERSION " started on %s PID:%d\n",
hostname, getpid ());
log (LOG_LOG,
"Written by Mark Spencer, Copyright (C) 1998, Adtran, Inc.\n");
log (LOG_LOG, "Forked by Scott Balmos and David Stipp, (C) 2001\n");
log (LOG_LOG, "Inhereted by Jeff McAdams, (C) 2002\n");
log (LOG_LOG, "%s version %s on a %s, port %d\n", uts.sysname,
uts.release, uts.machine, gconfig.port);
lac = laclist;
while (lac)
{
if (lac->autodial)
{
#ifdef DEBUG_MAGIC
log (LOG_DEBUG, "%s: Autodialing '%s'\n", __FUNCTION__,
lac->entname[0] ? lac->entname : "(unnamed)");
#endif
lac->active = -1;
switch_io = 1; /* If we're a LAC, autodials will be ICRQ's */
magic_lac_dial (lac);
}
lac = lac->next;
}
}
int main(int argc, char *argv[])
{
int sock;
struct sockaddr_in addr;
struct sockaddr_in src_addr;
socklen_t len_inet = 0;
ssize_t read_bytes = 0;
ssize_t wrote_bytes = 0;
int data_size = 0;
char buf[BUFSIZE];
// create socket
if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
perror("socket");
return -1;
}
// init server address
if (init_addr(&addr, "127.0.0.1", 1234) < 0) {
fprintf(stdout, "init_addr error\n");
return -1;
}
// associate socket and address and port
if (bind(sock, (struct sockaddr *) &addr,
sizeof(struct sockaddr_in)) < 0) {
close(sock);
perror("bind");
return -1;
}
len_inet = sizeof(src_addr);
printf("Listen on %s:%d\n", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));
// received data
for (;;) {
if ((read_bytes = recvfrom(sock, buf, BUFSIZE, 0, (struct sockaddr*) &src_addr, &len_inet)) < 0) {
perror("recvfrom");
return -1;
} else {
printf("Received from: %s, %d\n", inet_ntoa(src_addr.sin_addr), ntohs(src_addr.sin_port));
printf("%d bytes received\nReceived data: %s\n", (int)read_bytes, buf);
strcpy(buf, "ack");
data_size = strlen(buf) + 1;
// send data
if ((wrote_bytes = sendto(sock, buf, data_size, 0, (struct sockaddr*) &src_addr, sizeof(struct sockaddr_in))) < 0) {
perror("sendto");
return -1;
}
}
}
return 0;
}
//
// Constructor
//
InetSocketAddress::InetSocketAddress(in_port_t port, bool ipv6)
throw(IllegalArgumentException)
{
_ipv6 = ipv6;
// Inicializa el puerto
init_port(port);
// Inicializa la direccion IP
init_addr(NULL);
}
int sockaddr_to_ia (struct sockaddr * sap, int addr_size,
struct internet_addr * ia)
{
struct sockaddr_in * sin = (struct sockaddr_in *) sap;
struct sockaddr_in6 * sin6 = (struct sockaddr_in6 *) sap;
if ((sap->sa_family == AF_INET) &&
(addr_size >= sizeof (struct sockaddr_in))) {
init_addr (AF_INET, (unsigned char *) &(sin->sin_addr), sin->sin_port, ia);
return 1;
} else if ((sap->sa_family == AF_INET6) &&
(addr_size >= sizeof (struct sockaddr_in6))) {
init_addr (AF_INET6, (unsigned char *) &(sin6->sin6_addr),
sin6->sin6_port, ia);
return 1;
} else {
printf ("unable to create address info with family %d, size %d\n",
sap->sa_family, addr_size);
return 0;
}
}
int connect_block(const char *s, int defport) {
struct sockaddr_in a;
init_addr(a, s, defport);
int sock = socket(AF_INET, SOCK_STREAM, 0);
if (0 > sock)
fatal("socket: %s\n", strerror(errno));
if (0 > connect(sock, (struct sockaddr *)&a, sizeof(struct sockaddr)))
fatal("connect: %s: %s\n", s, strerror(errno));
return sock;
}
/* Dispatch routine for set/change password */
void
dispatch(void *handle, struct sockaddr *local_saddr,
const krb5_fulladdr *remote_faddr, krb5_data *request, int is_tcp,
verto_ctx *vctx, loop_respond_fn respond, void *arg)
{
krb5_error_code ret;
krb5_keytab kt = NULL;
kadm5_server_handle_t server_handle = (kadm5_server_handle_t)handle;
krb5_fulladdr local_faddr;
krb5_address **local_kaddrs = NULL, local_kaddr_buf;
krb5_data *response = NULL;
if (local_saddr == NULL) {
ret = krb5_os_localaddr(server_handle->context, &local_kaddrs);
if (ret != 0)
goto egress;
local_faddr.address = local_kaddrs[0];
local_faddr.port = 0;
} else {
local_faddr.address = &local_kaddr_buf;
init_addr(&local_faddr, local_saddr);
}
ret = krb5_kt_resolve(server_handle->context, "KDB:", &kt);
if (ret != 0) {
krb5_klog_syslog(LOG_ERR, _("chpw: Couldn't open admin keytab %s"),
krb5_get_error_message(server_handle->context, ret));
goto egress;
}
response = k5alloc(sizeof(krb5_data), &ret);
if (response == NULL)
goto egress;
ret = process_chpw_request(server_handle->context,
handle,
server_handle->params.realm,
kt,
&local_faddr,
remote_faddr,
request,
response);
egress:
if (ret)
krb5_free_data(server_handle->context, response);
krb5_free_addresses(server_handle->context, local_kaddrs);
krb5_kt_close(server_handle->context, kt);
(*respond)(arg, ret, ret == 0 ? response : NULL);
}
int connect_nonblock(const char *s, int defport) {
struct sockaddr_in a;
init_addr(a, s, defport);
int sock = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);
if (0 > sock)
fatal("socket: %s\n", strerror(errno));
int e = connect(sock, (struct sockaddr *)&a, sizeof(struct sockaddr));
if (0 == e || (0 > e && errno == EINPROGRESS))
return sock;
if (0 > e && errno != ECONNREFUSED)
fatal("connect: %s: %s\n", s, strerror(errno));
close(sock);
return -1;
}
int connect_to(const char *host, int port)
{
addr_t a;
char buf[64];
int s;
sprintf(buf, "%s:%d", host, port);
if (init_addr(&a, buf) != 0)
perror_fatal("connect %s:%u", host, port);
free(a.a_addr);
s = socket(a.name.sa_family, SOCK_STREAM, 0);
if (s == -1)
perror_fatal("socket");
if (nonblock_connect(s, &a.name, a.namelen, 1000) != 0)
perror_fatal("connect(%s:%d)", host, port);
return s;
}
/* returns 1 for success, 0 for failure */
int init_ai (int af, unsigned char * addr, int port, int nbits,
unsigned char * dest, struct addr_info * ai)
{
memset ((char *) ai, 0, sizeof (struct addr_info));
ai->nbits = nbits;
if (! (init_addr (af, addr, port, &(ai->ip))))
return 0;
memset (ai->destination, 0, ADDRESS_SIZE);
int nbytes = (nbits + 7) / 8;
if (nbytes > ADDRESS_SIZE) {
printf ("warning: in init_ai, nbits %d, nbytes %d, limiting to %d\n",
nbits, nbytes, ADDRESS_SIZE);
nbytes = ADDRESS_SIZE;
nbits = ADDRESS_SIZE * 8;
}
ai->nbits = nbits;
if (nbits > 0)
memcpy (ai->destination, dest, nbytes);
return 1;
}
int main( int argc, char ** argv )
{
char * ip;
if( argc == 1 ) {
ip = "127.0.0.1";
} else if( argc == 2 ) {
ip = argv[1];
} else {
fprintf( stderr, "Usage: %s ipaddress.\n", argv[0] );
exit( 1 );
}
int sock_connect_fd = socket( AF_INET, SOCK_STREAM, 0 );
struct sockaddr_in server_addr;
init_addr( &server_addr, PORT_NUM, ip );
int ret = connect( sock_connect_fd, ( sockaddr_t * ) &server_addr, ADDR_SIZE );
if( ret == -1 ) {
perror("connect");
exit( 1 );
}
char buf[1024];
bzero( buf, 1024 );
int packet_no = 0;
while( 1 ) {
packet_no ++;
buf[0] = 'A';
send( sock_connect_fd, buf, 1, 0 );
printf("Have sent %d packets.\n", packet_no );
if( packet_no == 10000 )
break;
}
close( sock_connect_fd );
return 0;
}
void read_send( const string & host, unsigned short port )
{
sockaddr_in to_addr = init_addr( host, port );
SOCKET s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
while( true )
{
string read;
cin >> read;
if( read == "quit" )
{
break;
}
cout << "[SYS:send]" << read << endl;
char send_buf[1024] = {0};
unsigned short message_len = static_cast<unsigned short>( read.length() );
::memcpy( send_buf, &message_len, sizeof(message_len) );
::memcpy( send_buf + sizeof(message_len), read.c_str(), message_len );
::sendto( s, send_buf, message_len + sizeof(message_len), 0, (SOCKADDR*)&to_addr, sizeof(to_addr) );
sockaddr_in server_addr;
int addr_size = sizeof(server_addr);
char buf[1024] = {0};
int size = ::recvfrom( s, buf, sizeof(buf), 0, (SOCKADDR*)&server_addr, &addr_size );
if( size == -1 ) {
cout << "[SYS]can not read response." << endl;
continue ;
}
::memcpy( &message_len, buf, sizeof(message_len) );
assert( size >= message_len + 2 );
string received( buf + sizeof( message_len ), message_len );
cout << received << endl;
}
}
int main() {
int fd = -1;
struct sockaddr_in addr;
socklen_t len = sizeof(addr);
int cfd = -1;
struct sockaddr_in caddr;
socklen_t clen = sizeof(caddr);
init_addr(&addr, AF_INET, 8888, "127.0.0.1");
if ( (fd = create_socket(AF_INET, SOCK_STREAM, 0)) < 0) {
printf("error: %s\n", strerror(errno));
return -1;
}
set_nonblock(fd);
set_reuseAddr(fd);
if ( bind_socket(fd, (struct sockaddr*)&addr, len) < 0) {
printf("error: %s\n", strerror(errno));
return -1;
}
if (listen(fd, 10) != 0) {
printf("error: %s\n", strerror(errno));
return -1;
}
cfd = accept(fd, (struct sockaddr*)&caddr, &clen);
if (cfd < 0) {
printf("-- error: %s : %s\n", get_errnoStr(errno), strerror(errno));
}
return 0;
}
void init (int argc,char *argv[])
{
struct lac *lac;
struct in_addr listenaddr;
struct utsname uts;
init_args (argc,argv);
srand( time(NULL) );
rand_source = 0;
init_addr ();
if (init_config ())
{
l2tp_log (LOG_CRIT, "%s: Unable to load config file\n", __FUNCTION__);
exit (1);
}
if (uname (&uts)<0)
{
l2tp_log (LOG_CRIT, "%s : Unable to determine host system\n",
__FUNCTION__);
exit (1);
}
init_tunnel_list (&tunnels);
if (init_network ())
exit (1);
if (gconfig.daemon)
daemonize ();
consider_pidfile();
signal (SIGTERM, &sigterm_handler);
signal (SIGINT, &sigint_handler);
signal (SIGCHLD, &sigchld_handler);
signal (SIGUSR1, &sigusr1_handler);
signal (SIGHUP, &sighup_handler);
init_scheduler ();
unlink(gconfig.controlfile);
mkfifo (gconfig.controlfile, 0600);
open_controlfd();
l2tp_log (LOG_INFO, "xl2tpd version " SERVER_VERSION " started on %s PID:%d\n",
hostname, getpid ());
l2tp_log (LOG_INFO,
"Written by Mark Spencer, Copyright (C) 1998, Adtran, Inc.\n");
l2tp_log (LOG_INFO, "Forked by Scott Balmos and David Stipp, (C) 2001\n");
l2tp_log (LOG_INFO, "Inherited by Jeff McAdams, (C) 2002\n");
l2tp_log (LOG_INFO, "Forked again by Xelerance (www.xelerance.com) (C) 2006\n");
listenaddr.s_addr = gconfig.listenaddr;
l2tp_log (LOG_INFO, "Listening on IP address %s, port %d\n",
inet_ntoa(listenaddr), gconfig.port);
lac = laclist;
while (lac)
{
if (lac->autodial)
{
#ifdef DEBUG_MAGIC
l2tp_log (LOG_DEBUG, "%s: Autodialing '%s'\n", __FUNCTION__,
lac->entname[0] ? lac->entname : "(unnamed)");
#endif
lac->active = -1;
switch_io = 1; /* If we're a LAC, autodials will be ICRQ's */
magic_lac_dial (lac);
}
lac = lac->next;
}
}
void init (int argc,char *argv[])
{
struct lac *lac;
struct in_addr listenaddr;
int myRet=0;
init_args (argc,argv);
srand( time(NULL) );
rand_source = 0;
init_addr ();
if (init_config ())
{
log (LOG_CRIT, "%s: Unable to load config file\n", __FUNCTION__);
exit (1);
}
init_tunnel_list (&tunnels);
if (init_network ())
exit (1);
//if (gconfig.daemon)
//daemonize ();
signal (SIGTERM, &death_handler);
signal (SIGINT, &death_handler);
signal (SIGCHLD, &child_handler);
signal (SIGUSR1, &status_handler);
signal (SIGHUP, &null_handler);
init_scheduler ();
unlink (gconfig.controlfile);
myRet=mkfifo (gconfig.controlfile, 0600);
// log (LOG_LOG,"gconfig.controlfile=%s, myRet=%d,errno=%d",gconfig.controlfile,myRet,errno);//Added for test
if(myRet<0)
{
log (LOG_CRIT, "%s: Unable to mkfifo %s.",__FUNCTION__, gconfig.controlfile);
exit (1);
}
control_fd = open (gconfig.controlfile, O_RDONLY | O_NONBLOCK, 0600);
if (control_fd < 0)
{
log (LOG_CRIT, "%s: Unable to open %s for reading.",
__FUNCTION__, gconfig.controlfile);
exit (1);
}
log (LOG_LOG, "l2tpd version " SERVER_VERSION " started on %s PID:%d\n",
hostname, getpid ());
log (LOG_LOG,
"Written by Mark Spencer, Copyright (C) 1998, Adtran, Inc.\n");
log (LOG_LOG, "Forked by Scott Balmos and David Stipp, (C) 2001\n");
log (LOG_LOG, "Inherited by Jeff McAdams, (C) 2002\n");
listenaddr.s_addr = gconfig.listenaddr;
log (LOG_LOG, "Listening on IP address %s, port %d\n",
inet_ntoa(listenaddr), gconfig.port);
lac = laclist;
while (lac)
{
if (lac->autodial)
{
#ifdef DEBUG_MAGIC
log (LOG_DEBUG, "%s: Autodialing '%s'\n", __FUNCTION__,
lac->entname[0] ? lac->entname : "(unnamed)");
#endif
lac->active = -1;
switch_io = 1; /* If we're a LAC, autodials will be ICRQ's */
magic_lac_dial (lac);
}
lac = lac->next;
}
}
int main(int argc, char **argv){
int mc_sock;
addr_t mc_addr;
ev_io mc_io;
sophiadb_t * db;
int c;
while (1) {
int option_index = 0;
static struct option long_options[] = {
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'V'},
{"max-clients", required_argument, 0, 'l'},
{0, 0, 0, 0}
};
c = getopt_long(argc, argv, "n:Vc:t", long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'c':
confilename = optarg;
break;
case 'n':
max_clients = atoi(optarg);
break;
case 'V':
printf("Version %s\n", MYMC_VERSION);
exit(0);
case 't':
is_trace = 1;
break; default:
usage(argv[0], c == 'h' ? EXIT_SUCCESS : EXIT_FAILURE);
}
}
if (confilename)
parse(confilename, &server_ctx);
else
parse( CONFIGFILE, &server_ctx);
//assert(server_ctx.logfile);
//assert(server_ctx.listen);
if (!server_ctx.listen) {
perror("undefined listen port");
exit(1);
}
flog = server_ctx.logfile ? fopen(server_ctx.logfile, "a+") : fopen("error.log", "a+");
if (flog) {
time_t lt;
lt = time(NULL);
fprintf(flog, "server started at %s\n",ctime(<));
} else {
perror("can not create log file");
exit(1);
}
daemonize(server_ctx.is_demonize, server_ctx.pidfile, server_ctx.username);
set_rlimit();
ignore_sigpipe();
init_addr(&mc_addr, server_ctx.listen);
mc_sock = socket(mc_addr.pf_family, SOCK_STREAM, 0);
if (mc_sock < 0) {
perror("can't create socket");
exit(1);
}
listen_sock(mc_sock, &mc_addr);
//TODO
if (is_trace)
printf("pid=%ld\n\n", (long)getpid());
clients = calloc(max_clients, sizeof(fd_ctx));
if (!clients) {
perror_fatal("Cannot allocate array for client descriptors!");
}
int i=0;
while(i < max_clients) {
if(clients[i].mc)
printf("init err %i\n", i);
i++;
}
db = db_init(&server_ctx);
assert(db);
struct ev_loop *loop = ev_default_loop(0);
assert(loop);
ev_set_userdata(loop,(void*)db);
ev_io_init( &mc_io, memcached_on_connect, mc_sock, EV_READ);
ev_io_start(loop, &mc_io);
struct ev_timer timeout_watcher;
ev_init(&timeout_watcher, periodic_watcher);
timeout_watcher.repeat = TIME_CHECK_INTERVAL;
ev_timer_again(loop, &timeout_watcher);
struct ev_signal signal_watcher,signal_watcher2;
// ev_signal_init (&signal_watcher, sigint_cb, SIGINT);
// ev_signal_start (loop, &signal_watcher);
ev_signal_init (&signal_watcher, sigint_cb, SIGTERM);
ev_signal_start (loop, &signal_watcher);
ev_signal_init (&signal_watcher2, sighup_cb, SIGHUP);
ev_signal_start (loop, &signal_watcher2);
//start server
time(&stats.uptime);
gettimeofday(&t_start, NULL);
// event loop
ev_loop(loop, 0);
cllear_mc_all();
close(mc_sock);
if (clients)
free(clients);
//ev_loop_destroy(loop);
destroy(db);
if (mc_addr.a_addr) free(mc_addr.a_addr);
if (server_ctx.pidfile) {
if( unlink(server_ctx.pidfile))
printf("cannot delete pid file %s %s\n",server_ctx.pidfile, strerror(errno));
}
free_config();
if (flog) {
time_t lt;
lt = time(NULL);
fprintf(flog, "server finis Ok at %s\n",ctime(<));
fclose(flog);
}
return 0;
}
/*
* Class: net_RawIPv6Socket
* Method: _send
* Signature: (I[B[BI[BII)I
*/
JNIEXPORT jint JNICALL Java_net_RawIPv6Socket__1send
(JNIEnv *env, jobject obj, jint socket, jbyteArray srcaddress, jbyteArray dstaddress, jint dstscopeid,
jbyteArray data, jint offset, jint len, jint ttl, jint tos) {
int result;
jbyte *buf;
struct sockaddr_in6 sin6;
struct sockaddr *saddr;
struct msghdr mhdr;
struct iovec iovecs[1];
char msg_control_buffer6[CMSG_SPACE(sizeof(int))+CMSG_SPACE(sizeof(int))+CMSG_SPACE(sizeof(struct in6_pktinfo))];
struct cmsghdr *cmsg;
int controllen;
struct in6_pktinfo *pktinfo6;
int *sent_ttl;
int *sent_tos;
saddr = fill_sockaddr_in6(env, &sin6, dstaddress, dstscopeid);
buf = (*env)->GetByteArrayElements(env, data, NULL);
mhdr.msg_name = saddr;
mhdr.msg_namelen = sizeof(sin6);
iovecs[0].iov_base= &buf[offset];
iovecs[0].iov_len = len;
mhdr.msg_iov = &iovecs[0];
mhdr.msg_iovlen = 1;
mhdr.msg_control = msg_control_buffer6;
mhdr.msg_controllen = sizeof(msg_control_buffer6);
controllen = 0;
cmsg = CMSG_FIRSTHDR(&mhdr);
cmsg->cmsg_level = IPPROTO_IPV6;
cmsg->cmsg_type = IPV6_PKTINFO;
cmsg->cmsg_len = 0;
pktinfo6 = (struct in6_pktinfo*) CMSG_DATA(cmsg);
pktinfo6->ipi6_ifindex = 0;
pktinfo6->ipi6_addr = in6addr_any;//source address not specified
if (srcaddress != NULL)
init_addr(env,&pktinfo6->ipi6_addr,srcaddress,sizeof(struct in6_addr));
controllen += CMSG_SPACE(sizeof(struct in6_pktinfo));
cmsg = (struct cmsghdr *)((unsigned char*)cmsg + CMSG_SPACE(sizeof(struct in6_pktinfo)));
if (ttl >=0) {
cmsg->cmsg_level = IPPROTO_IPV6;
cmsg->cmsg_type = IPV6_HOPLIMIT;
cmsg->cmsg_len = CMSG_LEN(sizeof(int));
sent_ttl = (int *)CMSG_DATA(cmsg);
*sent_ttl = ttl;
controllen += CMSG_SPACE(sizeof(int));
cmsg = (struct cmsghdr *)((unsigned char*)cmsg + CMSG_SPACE(sizeof(int)));
}
if (tos >=0) {
cmsg = CMSG_NXTHDR(&mhdr,cmsg);
cmsg->cmsg_level = IPPROTO_IPV6;
cmsg->cmsg_type = IPV6_TCLASS;
cmsg->cmsg_len = CMSG_LEN(sizeof(int));
sent_tos = (int *)CMSG_DATA(cmsg);
*sent_tos = tos;
controllen += CMSG_SPACE(sizeof(int));
cmsg = (struct cmsghdr *)((unsigned char*)cmsg + CMSG_SPACE(sizeof(int)));
}
mhdr.msg_controllen = controllen;
result = sendmsg(socket,&mhdr,0);
(*env)->ReleaseByteArrayElements(env, data, buf, JNI_ABORT);
return result;
}
