util/src/network_handler.c - axis-axis2-c-core - Git at Google


 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <string.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <axutil_network_handler.h>
 #include <fcntl.h>

 #if defined(WIN32)
 static int is_init_socket = 0;
 axis2_bool_t axis2_init_socket(
     );
 #endif

 AXIS2_EXTERN axis2_socket_t AXIS2_CALL
 axutil_network_handler_open_socket(
     const axutil_env_t * env,
     char *server,
     int port)
 {
     axis2_socket_t sock = AXIS2_INVALID_SOCKET;
     struct sockaddr_in sock_addr;
     struct linger ll;
     int nodelay = 1;

 #if defined(WIN32)
     if (is_init_socket == 0)
     {
         axis2_init_socket();
         is_init_socket = 1;
     }
 #endif

     AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE);
     AXIS2_PARAM_CHECK(env->error, server, AXIS2_CRITICAL_FAILURE);

     if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
         /*nnn AF_INET is not defined in sys/socket.h but PF_INET */
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SOCKET_ERROR, AXIS2_FAILURE);
         return AXIS2_INVALID_SOCKET;
     }

     memset(&sock_addr, 0, sizeof(sock_addr));
     sock_addr.sin_family = AF_INET;
     sock_addr.sin_addr.s_addr = inet_addr(server);  /*nnn arpa/inet.d */

     if (sock_addr.sin_addr.s_addr == AXIS2_INADDR_NONE) /*nnn netinet/in.h */
     {

         /**
          * server may be a host name
          */
         struct hostent *lphost = NULL;
         lphost = gethostbyname(server);

         if (lphost)
         {
             sock_addr.sin_addr.s_addr =
                 ((struct in_addr *) lphost->h_addr)->s_addr;
         }
         else
         {
             AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_ADDRESS,
                             AXIS2_FAILURE);
             return AXIS2_INVALID_SOCKET;
         }
     }

     sock_addr.sin_port = htons((axis2_unsigned_short_t) port);

     /** Connect to server */
     if (connect(sock, (struct sockaddr *) &sock_addr, sizeof(sock_addr)) < 0)
     {
         AXIS2_CLOSE_SOCKET(sock);
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SOCKET_ERROR, AXIS2_FAILURE);
         return AXIS2_INVALID_SOCKET;
     }
     setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (const char *) &nodelay,
                sizeof(nodelay));
     ll.l_onoff = 1;
     ll.l_linger = 5;
     setsockopt(sock, SOL_SOCKET, SO_LINGER, (const char *) &ll,
                sizeof(struct linger));
     return sock;
 }

 AXIS2_EXTERN axis2_socket_t AXIS2_CALL
 axutil_network_handler_create_server_socket(
     const axutil_env_t * env,
     int port)
 {
     axis2_socket_t sock = AXIS2_INVALID_SOCKET;
     axis2_socket_t i = 0;
     struct sockaddr_in sock_addr;

     AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE);
 #if defined(WIN32)
     if (is_init_socket == 0)
     {
         axis2_init_socket();
         is_init_socket = 1;
     }
 #endif
     sock = socket(AF_INET, SOCK_STREAM, 0);
     if (sock < 0)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SOCKET_ERROR, AXIS2_FAILURE);
         return AXIS2_INVALID_SOCKET;
     }

     /** Address re-use */
     i = 1;
     setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *) &i, sizeof(axis2_socket_t));    /*nnn casted 4th param to char* */

     /** Exec behaviour */
     AXIS2_CLOSE_SOCKET_ON_EXIT(sock) memset(&sock_addr, 0, sizeof(sock_addr));

     sock_addr.sin_family = AF_INET;
     sock_addr.sin_addr.s_addr = htonl(INADDR_ANY);
     sock_addr.sin_port = htons((axis2_unsigned_short_t) port);

     /* Bind the socket to our port number */
     if (bind(sock, (struct sockaddr *) &sock_addr, sizeof(sock_addr)) < 0)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SOCKET_BIND_FAILED,
                         AXIS2_FAILURE);
         return AXIS2_INVALID_SOCKET;
     }
     if (listen(sock, 50) < 0)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SOCKET_LISTEN_FAILED,
                         AXIS2_FAILURE);
         return AXIS2_INVALID_SOCKET;
     }
     return sock;
 }

 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axutil_network_handler_close_socket(
     const axutil_env_t * env,
     axis2_socket_t socket)
 {
     int i = 0;
     char buf[32];
     AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE);
     if (socket < 0)
     {
         AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_SOCKET, AXIS2_FAILURE);
         return AXIS2_FAILURE;
     }
     shutdown(socket, AXIS2_SHUT_WR);
     axutil_network_handler_set_sock_option(env, socket, SO_RCVTIMEO, 1);
     i = recv(socket, buf, 32, 0);
     AXIS2_CLOSE_SOCKET(socket);
     return AXIS2_SUCCESS;
 }

 AXIS2_EXTERN axis2_status_t AXIS2_CALL
 axutil_network_handler_set_sock_option(
     const axutil_env_t * env,
     axis2_socket_t socket,
     int option,
     int value)
 {
     if (option == SO_RCVTIMEO || option == SO_SNDTIMEO)
     {
 #if defined(WIN32)
         DWORD tv = value;       //windows expects milliseconds in a DWORD
 #else
         struct timeval tv;
         /* we deal with milliseconds */
         tv.tv_sec = value / 1000;
         tv.tv_usec = (value % 1000) * 1000;
 #endif

         setsockopt(socket, SOL_SOCKET, option, (char *) &tv, sizeof(tv));
         return AXIS2_SUCCESS;
     }
     return AXIS2_FAILURE;
 }

 AXIS2_EXTERN axis2_socket_t AXIS2_CALL
 axutil_network_handler_svr_socket_accept(
     const axutil_env_t * env,
     axis2_socket_t svr_socket)
 {
     struct sockaddr cli_addr;

     struct linger ll;
     int nodelay = 1;
     axis2_socket_len_t cli_len = 0;
     axis2_socket_t cli_socket = AXIS2_INVALID_SOCKET;
     AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE);

     cli_len = sizeof(cli_addr);
     cli_socket = accept(svr_socket, (struct sockaddr *) &cli_addr, &cli_len);
     if (cli_socket < 0)
         AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
                         "[Axis2][network_handler] Socket accept \
                 failed");

     setsockopt(svr_socket, IPPROTO_TCP, TCP_NODELAY, &nodelay, sizeof(nodelay));
     ll.l_onoff = 1;
     ll.l_linger = 5;
     setsockopt(cli_socket, SOL_SOCKET, SO_LINGER, &ll, sizeof(struct linger));
     return cli_socket;
 }

 #if defined (WIN32)
 axis2_bool_t
 axis2_init_socket(
     )
 {
     WORD wVersionRequested;
     WSADATA wsaData;
     int err;
     int sock_opt = SO_SYNCHRONOUS_NONALERT;

     wVersionRequested = MAKEWORD(2, 2);

     err = WSAStartup(wVersionRequested, &wsaData);

     if (err != 0)
         return 0;               //WinSock 2.2 not found

     /*   Confirm that the WinSock DLL supports 2.2. */
     /*   Note that if the DLL supports versions greater */
     /*   than 2.2 in addition to 2.2, it will still return */
     /*   2.2 in wVersion since that is the version we */
     /*   requested. */

     if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2)
     {
         WSACleanup();
         return 0;               //WinSock 2.2 not supported
     }

     /**
      *   Enable the use of sockets as filehandles
      */
     /*
      * setsockopt(INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, (char *)&sock_opt,
      sizeof(sock_opt));*/
     return 1;
 }
 #endif

 AXIS2_EXTERN axis2_char_t *AXIS2_CALL
 axutil_network_handler_get_svr_ip(
     const axutil_env_t * env,
     axis2_socket_t socket)
 {
     struct sockaddr_in addr;

     axis2_socket_len_t len = sizeof(addr);
     char *ret = NULL;
     memset(&addr, 0, sizeof(addr));
     if (getsockname(socket, (struct sockaddr *) &addr, &len) < 0)
     {
         return NULL;
     }
     ret = inet_ntoa(addr.sin_addr);
     return ret;
 }

 AXIS2_EXTERN axis2_char_t *AXIS2_CALL
 axutil_network_handler_get_peer_ip(
     const axutil_env_t * env,
     axis2_socket_t socket)
 {
     struct sockaddr_in addr;

     axis2_socket_len_t len = sizeof(addr);
     char *ret = NULL;
     memset(&addr, 0, sizeof(addr));
     if (getpeername(socket, (struct sockaddr *) &addr, &len) < 0)
     {
         return NULL;
     }
     ret = inet_ntoa(addr.sin_addr);
     return ret;
 }

	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <string.h>
	#include <stdlib.h>
	#include <stdio.h>
	#include <axutil_network_handler.h>
	#include <fcntl.h>

	#if defined(WIN32)
	static int is_init_socket = 0;
	axis2_bool_t axis2_init_socket(
	);
	#endif

	AXIS2_EXTERN axis2_socket_t AXIS2_CALL
	axutil_network_handler_open_socket(
	const axutil_env_t * env,
	char *server,
	int port)
	{
	axis2_socket_t sock = AXIS2_INVALID_SOCKET;
	struct sockaddr_in sock_addr;
	struct linger ll;
	int nodelay = 1;

	#if defined(WIN32)
	if (is_init_socket == 0)
	{
	axis2_init_socket();
	is_init_socket = 1;
	}
	#endif

	AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE);
	AXIS2_PARAM_CHECK(env->error, server, AXIS2_CRITICAL_FAILURE);

	if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
	/nnn AF_INET is not defined in sys/socket.h but PF_INET /
	{
	AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SOCKET_ERROR, AXIS2_FAILURE);
	return AXIS2_INVALID_SOCKET;
	}

	memset(&sock_addr, 0, sizeof(sock_addr));
	sock_addr.sin_family = AF_INET;
	sock_addr.sin_addr.s_addr = inet_addr(server); /nnn arpa/inet.d /

	if (sock_addr.sin_addr.s_addr == AXIS2_INADDR_NONE) /nnn netinet/in.h /
	{

	/**
	* server may be a host name
	*/
	struct hostent *lphost = NULL;
	lphost = gethostbyname(server);

	if (lphost)
	{
	sock_addr.sin_addr.s_addr =
	((struct in_addr *) lphost->h_addr)->s_addr;
	}
	else
	{
	AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_ADDRESS,
	AXIS2_FAILURE);
	return AXIS2_INVALID_SOCKET;
	}
	}

	sock_addr.sin_port = htons((axis2_unsigned_short_t) port);

	/** Connect to server */
	if (connect(sock, (struct sockaddr *) &sock_addr, sizeof(sock_addr)) < 0)
	{
	AXIS2_CLOSE_SOCKET(sock);
	AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SOCKET_ERROR, AXIS2_FAILURE);
	return AXIS2_INVALID_SOCKET;
	}
	setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (const char *) &nodelay,
	sizeof(nodelay));
	ll.l_onoff = 1;
	ll.l_linger = 5;
	setsockopt(sock, SOL_SOCKET, SO_LINGER, (const char *) &ll,
	sizeof(struct linger));
	return sock;
	}

	AXIS2_EXTERN axis2_socket_t AXIS2_CALL
	axutil_network_handler_create_server_socket(
	const axutil_env_t * env,
	int port)
	{
	axis2_socket_t sock = AXIS2_INVALID_SOCKET;
	axis2_socket_t i = 0;
	struct sockaddr_in sock_addr;

	AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE);
	#if defined(WIN32)
	if (is_init_socket == 0)
	{
	axis2_init_socket();
	is_init_socket = 1;
	}
	#endif
	sock = socket(AF_INET, SOCK_STREAM, 0);
	if (sock < 0)
	{
	AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SOCKET_ERROR, AXIS2_FAILURE);
	return AXIS2_INVALID_SOCKET;
	}

	/** Address re-use */
	i = 1;
	setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char ) &i, sizeof(axis2_socket_t)); /nnn casted 4th param to char* */

	/** Exec behaviour */
	AXIS2_CLOSE_SOCKET_ON_EXIT(sock) memset(&sock_addr, 0, sizeof(sock_addr));

	sock_addr.sin_family = AF_INET;
	sock_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	sock_addr.sin_port = htons((axis2_unsigned_short_t) port);

	/* Bind the socket to our port number */
	if (bind(sock, (struct sockaddr *) &sock_addr, sizeof(sock_addr)) < 0)
	{
	AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SOCKET_BIND_FAILED,
	AXIS2_FAILURE);
	return AXIS2_INVALID_SOCKET;
	}
	if (listen(sock, 50) < 0)
	{
	AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SOCKET_LISTEN_FAILED,
	AXIS2_FAILURE);
	return AXIS2_INVALID_SOCKET;
	}
	return sock;
	}

	AXIS2_EXTERN axis2_status_t AXIS2_CALL
	axutil_network_handler_close_socket(
	const axutil_env_t * env,
	axis2_socket_t socket)
	{
	int i = 0;
	char buf[32];
	AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE);
	if (socket < 0)
	{
	AXIS2_ERROR_SET(env->error, AXIS2_ERROR_INVALID_SOCKET, AXIS2_FAILURE);
	return AXIS2_FAILURE;
	}
	shutdown(socket, AXIS2_SHUT_WR);
	axutil_network_handler_set_sock_option(env, socket, SO_RCVTIMEO, 1);
	i = recv(socket, buf, 32, 0);
	AXIS2_CLOSE_SOCKET(socket);
	return AXIS2_SUCCESS;
	}

	AXIS2_EXTERN axis2_status_t AXIS2_CALL
	axutil_network_handler_set_sock_option(
	const axutil_env_t * env,
	axis2_socket_t socket,
	int option,
	int value)
	{
	if (option == SO_RCVTIMEO \|\| option == SO_SNDTIMEO)
	{
	#if defined(WIN32)
	DWORD tv = value; //windows expects milliseconds in a DWORD
	#else
	struct timeval tv;
	/* we deal with milliseconds */
	tv.tv_sec = value / 1000;
	tv.tv_usec = (value % 1000) * 1000;
	#endif

	setsockopt(socket, SOL_SOCKET, option, (char *) &tv, sizeof(tv));
	return AXIS2_SUCCESS;
	}
	return AXIS2_FAILURE;
	}

	AXIS2_EXTERN axis2_socket_t AXIS2_CALL
	axutil_network_handler_svr_socket_accept(
	const axutil_env_t * env,
	axis2_socket_t svr_socket)
	{
	struct sockaddr cli_addr;

	struct linger ll;
	int nodelay = 1;
	axis2_socket_len_t cli_len = 0;
	axis2_socket_t cli_socket = AXIS2_INVALID_SOCKET;
	AXIS2_ENV_CHECK(env, AXIS2_CRITICAL_FAILURE);

	cli_len = sizeof(cli_addr);
	cli_socket = accept(svr_socket, (struct sockaddr *) &cli_addr, &cli_len);
	if (cli_socket < 0)
	AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
	"[Axis2][network_handler] Socket accept \
	failed");

	setsockopt(svr_socket, IPPROTO_TCP, TCP_NODELAY, &nodelay, sizeof(nodelay));
	ll.l_onoff = 1;
	ll.l_linger = 5;
	setsockopt(cli_socket, SOL_SOCKET, SO_LINGER, &ll, sizeof(struct linger));
	return cli_socket;
	}

	#if defined (WIN32)
	axis2_bool_t
	axis2_init_socket(
	)
	{
	WORD wVersionRequested;
	WSADATA wsaData;
	int err;
	int sock_opt = SO_SYNCHRONOUS_NONALERT;

	wVersionRequested = MAKEWORD(2, 2);

	err = WSAStartup(wVersionRequested, &wsaData);

	if (err != 0)
	return 0; //WinSock 2.2 not found

	/* Confirm that the WinSock DLL supports 2.2. */
	/* Note that if the DLL supports versions greater */
	/* than 2.2 in addition to 2.2, it will still return */
	/* 2.2 in wVersion since that is the version we */
	/* requested. */

	if (LOBYTE(wsaData.wVersion) != 2 \|\| HIBYTE(wsaData.wVersion) != 2)
	{
	WSACleanup();
	return 0; //WinSock 2.2 not supported
	}

	/**
	* Enable the use of sockets as filehandles
	*/
	/*
	* setsockopt(INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, (char *)&sock_opt,
	sizeof(sock_opt));*/
	return 1;
	}
	#endif

	AXIS2_EXTERN axis2_char_t *AXIS2_CALL
	axutil_network_handler_get_svr_ip(
	const axutil_env_t * env,
	axis2_socket_t socket)
	{
	struct sockaddr_in addr;

	axis2_socket_len_t len = sizeof(addr);
	char *ret = NULL;
	memset(&addr, 0, sizeof(addr));
	if (getsockname(socket, (struct sockaddr *) &addr, &len) < 0)
	{
	return NULL;
	}
	ret = inet_ntoa(addr.sin_addr);
	return ret;
	}

	AXIS2_EXTERN axis2_char_t *AXIS2_CALL
	axutil_network_handler_get_peer_ip(
	const axutil_env_t * env,
	axis2_socket_t socket)
	{
	struct sockaddr_in addr;

	axis2_socket_len_t len = sizeof(addr);
	char *ret = NULL;
	memset(&addr, 0, sizeof(addr));
	if (getpeername(socket, (struct sockaddr *) &addr, &len) < 0)
	{
	return NULL;
	}
	ret = inet_ntoa(addr.sin_addr);
	return ret;
	}