예제 #1
0
파일: query.c 프로젝트: JDsolution/ipnc
int __cdecl
#else
int
#endif
main(
	int		argc,
	char	**	argv)
{
	sw_discovery		discovery;
	sw_discovery_oid	oid;
	sw_result			err;

	err = sw_discovery_init(&discovery);
	sw_check_okay(err, exit);

	if (argc != 4)
	{
		fprintf(stderr, "usage: mDNSBrowse <name> <rrtype> <rrclass>\n");
		return -1;
	}

	err = sw_discovery_query_record(discovery, 0, 0, argv[1], atoi(argv[2]), atoi(argv[3]), query_record_reply, NULL, &oid);
	sw_check_okay(err, exit);

	err = sw_discovery_run(discovery);
	sw_check_okay(err, exit);

exit:

	return err;
}
예제 #2
0
int __cdecl
#else
int
#endif
main(
	int		argc,
	char	**	argv)
{
	sw_discovery		discovery;
	sw_discovery_oid	oid;
	sw_result			err;

	err = sw_discovery_init(&discovery);
	sw_check_okay(err, exit);

	if (argc != 2)
	{
		fprintf(stderr, "usage: mDNSBrowse <type>\n");
		return -1;
	}

	err = sw_discovery_browse(discovery, 0, argv[1], NULL, my_browser, NULL, &oid);
	sw_check_okay(err, exit);

	err = sw_discovery_run(discovery);
	sw_check_okay(err, exit);

exit:

	return err;
}
예제 #3
0
sw_result
sw_ipv4_address_init_from_this_host(
				sw_ipv4_address	*	self)
{
#if defined(__VXWORKS__)
		
	sw_int8 current_addr[INET_ADDR_LEN];      
		
	if (ifAddrGet(sysEnetNameGet(), current_addr) != OK)
	{
		sw_debug(SW_LOG_ERROR, "sw_ipv4_address_init_from_this_host", "ifAddrGet() failed\n");
		return SW_E_INIT;
	}
      
	self->m_addr = inet_addr(current_addr);

#else
		
	struct sockaddr_in	addr;
	sw_result				err;
	sw_sockdesc_t			desc;
	sw_socklen_t			len;

	desc = socket(AF_INET, SOCK_DGRAM, 0);
	sw_check(desc != SW_INVALID_SOCKET, exit, err = SW_E_UNKNOWN);

	sw_memset(&addr, 0, sizeof(addr));
	addr.sin_family		=	AF_INET;
	addr.sin_addr.s_addr =	inet_addr("192.168.1.1");
	addr.sin_port			=	htons(5555);

	err = connect(desc, (struct sockaddr*) &addr, sizeof(addr));
	sw_check_okay(err, exit);
	
	sw_memset(&addr, 0, sizeof(addr));
	len = sizeof(addr);
	err = getsockname(desc, (struct sockaddr*) &addr, &len);
	sw_check_okay(err, exit);

	self->m_addr = addr.sin_addr.s_addr;

#endif

exit:

	if (desc != SW_INVALID_SOCKET)
	{
		sw_close_socket(desc);
	}

	if (err != SW_OKAY)
	{
		err = sw_ipv4_address_init_from_address(self, sw_ipv4_address_loopback());
	}

	return err;
}
예제 #4
0
sw_result
sw_corby_channel_init(
                        sw_corby_channel		*	self,
								struct _sw_corby_orb	*	orb,
								sw_socket					socket,
								sw_socket_options			options,
								sw_size_t					bufsize)
{
	sw_result err;

 	*self = (sw_corby_channel) sw_malloc(sizeof(struct _sw_corby_channel));
	err = sw_translate_error(*self, SW_E_MEM);
	sw_check_okay_log(err, exit);

	sw_memset(*self, 0, sizeof(struct _sw_corby_channel));

   if (options)
   {
		err = sw_socket_set_options(socket, options);
		sw_check_okay(err, exit);
	}
   
	err = sw_ipv4_address_init(&(*self)->m_from);
	sw_check_okay(err, exit);

	(*self)->m_orb		=	orb;
   (*self)->m_socket	=	socket;
	(*self)->m_refs	=	1;
	(*self)->m_state	=	Waiting;
   
	err = sw_corby_message_init(&(*self)->m_message);
	sw_check_okay(err, exit);

	err = sw_corby_buffer_init_with_size(&(*self)->m_send_buffer, (bufsize) ? bufsize : SW_CORBY_CHANNEL_DEFAULT_BUFFER_SIZE);
	sw_check_okay(err, exit);

	err = sw_corby_buffer_init_with_size(&(*self)->m_read_buffer, (bufsize) ? bufsize : SW_CORBY_CHANNEL_DEFAULT_BUFFER_SIZE);
	sw_check_okay(err, exit);

exit:

	if (err && *self)
	{
		sw_corby_channel_fina(*self);
	}
   
   return err;
}
예제 #5
0
static sw_result
sw_socket_udp_recvfrom(
					sw_socket				self,
					sw_octets				buffer,
					sw_size_t				max,
					sw_size_t			*	len,
					sw_ipv4_address	*	from,
					sw_port				*	from_port,
					sw_ipv4_address	*	dest,
					sw_uint32			*	interface_index)
{
	struct sockaddr_in	from_addr;
	struct in_addr			dest_addr;
	sw_result				err;

	err = sw_socket_udp_really_recvfrom(self, buffer, max, len, (struct sockaddr*) &from_addr, sizeof(from_addr), &dest_addr, interface_index);
	sw_check_okay(err, exit);

	sw_ipv4_address_init_from_saddr(from, from_addr.sin_addr.s_addr);
	*from_port	= ntohs(from_addr.sin_port);  

	if (dest)
	{
		sw_ipv4_address_init_from_saddr(dest, dest_addr.s_addr);
	}

exit:

	return err;
}
예제 #6
0
static sw_result
sw_socket_tcp_close(
               sw_socket	self)
{
	int			res;
	sw_result	err;

	sw_debug(SW_LOG_VERBOSE, "sw_socket_tcp_close() : fd = %d\n", self->m_desc);

#if defined(WIN32)
	res = shutdown(self->m_desc, SD_SEND);
#else
	res = shutdown(self->m_desc, 2);

	/*
	 * Patch from Michael ([email protected])
	 * 
	 * we should only fail here if errno isn't ENOTCONN or ENOENT ( Solaris 9 sets errno to ENOENT 
	 * if the socket isn't connected, despite the man page for shutdown saying it would use
	 * ENOTCONN )
	 */
	err = sw_translate_error((res == 0) || (errno == ENOENT) || (errno == ENOTCONN), sw_socket_errno());
   sw_check_okay(err, exit);
#endif

	res = sw_close_socket(self->m_desc);
	err = sw_translate_error(res == 0, sw_socket_errno());
	sw_check_okay_log(err, exit);

exit:
   
	self->m_connected = SW_FALSE;

	return err;
}
예제 #7
0
sw_result
sw_multicast_socket_super_init(
               sw_socket	self)
{
	int			opt = 1;
	int			res;
	sw_result	err;
   
	err = sw_socket_init(self, SW_FALSE, &sw_socket_udp_connect, &sw_socket_udp_send, &sw_socket_udp_sendto, &sw_socket_udp_recv, &sw_socket_udp_recvfrom, &sw_socket_udp_close);
	sw_check_okay(err, exit);

	self->m_desc = socket(AF_INET, SOCK_DGRAM, 0);
	err = sw_translate_error(self->m_desc != SW_INVALID_SOCKET, sw_socket_errno());
	sw_check_okay_log(err, exit);

#if defined(__APPLE__) || defined(__VXWORKS__) || defined(__FreeBSD__) || defined(__NetBSD__)
   res = setsockopt(self->m_desc, SOL_SOCKET, SO_REUSEPORT, (char*) &opt, sizeof(opt));
#else
	res = setsockopt(self->m_desc, SOL_SOCKET, SO_REUSEADDR, (char*) &opt, sizeof(opt));
#endif

	err = sw_translate_error(res == 0, sw_socket_errno());
	sw_check_okay_log(err, exit);

exit:

	return err;
}
예제 #8
0
static sw_result HOWL_API
my_resolver(
				sw_discovery			discovery,
				sw_discovery_oid		oid,
				sw_uint32				interface_index,
				sw_const_string		name,
				sw_const_string		type,
				sw_const_string		domain,
				sw_ipv4_address		address,
				sw_port					port,
				sw_octets				text_record,
				sw_uint32				text_record_len,
				sw_opaque_t				extra)
{
	sw_text_record_iterator				it;
	sw_int8									name_buf[16];
	sw_int8									key[SW_TEXT_RECORD_MAX_LEN];
	sw_int8									sval[SW_TEXT_RECORD_MAX_LEN];
	sw_uint8									oval[SW_TEXT_RECORD_MAX_LEN];
	sw_uint32								oval_len;
	sw_result								err = SW_OKAY;

	sw_discovery_cancel(discovery, oid);

	fprintf(stderr, "resolve reply: 0x%x %s %s %s %s %d\n", interface_index, name, type, domain, sw_ipv4_address_name(address, name_buf, 16), port);

	if ((text_record_len > 0) && (text_record) && (*text_record != '\0'))
	{
		err = sw_text_record_iterator_init(&it, text_record, text_record_len);
		sw_check_okay(err, exit);

		while (sw_text_record_iterator_next(it, key, oval, &oval_len) == SW_OKAY)
		{
			fprintf(stderr, "Txt: [%s]=[%s] - (%d bytes)\n", key, oval, oval_len);
		}

		err = sw_text_record_iterator_fina(it);
		sw_check_okay(err, exit);
	}

exit:

	return err;
}
예제 #9
0
sw_result
sw_socket_accept(
               sw_socket		self,
               sw_socket	*	socket)
{
   struct sockaddr_in	addr;
   sw_sockdesc_t			desc;
   sw_socklen_t			len;
	int						nodelay = 1;
	struct linger			l;
	int						res;
	sw_result				err;
   
	len = sizeof(addr);
   sw_memset(&addr, 0, sizeof(addr));
	desc = accept(self->m_desc, (struct sockaddr*) &addr, &len);
	err = sw_translate_error(desc != SW_INVALID_SOCKET, sw_socket_errno());
	sw_check_okay(err, exit);

	res = setsockopt(desc, IPPROTO_TCP, TCP_NODELAY, (char*) &nodelay, sizeof(nodelay));
	err = sw_translate_error(res == 0, sw_socket_errno());
	sw_check_okay_log(err, exit);
 
	l.l_onoff	= 0;
	l.l_linger	= 0;

	res = setsockopt(desc, SOL_SOCKET, SO_LINGER, (char*) &l, sizeof(l));
	err = sw_translate_error(res == 0, sw_socket_errno());
	sw_check_okay_log(err, exit);

	err = sw_tcp_socket_init_with_desc(socket, desc);
	sw_check_okay(err, exit);

exit:

	return err;
}
예제 #10
0
sw_result
sw_tcp_socket_super_init_with_desc(
					sw_socket		self,
					sw_sockdesc_t	desc)
{
	sw_result err;

	err = sw_socket_init(self, SW_FALSE, &sw_socket_tcp_connect, &sw_socket_tcp_send, &sw_socket_tcp_sendto, &sw_socket_tcp_recv, &sw_socket_tcp_recvfrom, &sw_socket_tcp_close);
	sw_check_okay(err, exit);

	self->m_desc = desc;

exit:

	return err;
}
예제 #11
0
sw_result
sw_udp_socket_super_init(
               sw_socket self)
{
	sw_result err;

	err = sw_socket_init(self, SW_FALSE, &sw_socket_udp_connect, &sw_socket_udp_send, &sw_socket_udp_sendto, &sw_socket_udp_recv, &sw_socket_udp_recvfrom, &sw_socket_udp_close);
	sw_check_okay(err, exit);

 	self->m_desc = socket(AF_INET, SOCK_DGRAM, 0);
	err = sw_translate_error(self->m_desc != SW_INVALID_SOCKET, sw_socket_errno());
	sw_check_okay_log(err, exit);

exit:

	return err;
}
예제 #12
0
sw_result
sw_socket_join_multicast_group(
               sw_socket			self,
					sw_ipv4_address	local_address,
					sw_ipv4_address	multicast_address,
               sw_uint32			ttl)
{
	struct in_addr				addr;
   struct ip_mreq				mreq;	
#if defined(__sun) || defined(__VXWORKS__) || defined(__NetBSD__) || defined(__OpenBSD__)
	sw_uint8					real_ttl				= (sw_uint8) ttl;
#else
	sw_uint32					real_ttl				= ttl;
#endif
	int							res;
	sw_result					err;

   /*
      initialize the group membership
   */
	sw_memset(&addr, 0, sizeof(addr));
	addr.s_addr = sw_ipv4_address_saddr(local_address);
   sw_memset(&mreq, 0, sizeof(mreq));

#if defined(__VXWORKS__)

	/*
		VxWorks doesn't like it if we try and use INADDR_ANY for use in
		setting up multicast sockets.

		So we please it.
	*/
	if (sw_ipv4_address_is_any(local_address))
	{
		sw_ipv4_address current_address;

		err = sw_ipv4_address_init_from_this_host(&current_address);
		sw_check_okay(err, exit);

		mreq.imr_interface.s_addr	= sw_ipv4_address_saddr(current_address);
	}
	else
	{
		mreq.imr_interface = addr;
	}

#else

   mreq.imr_interface = addr;

#endif

	mreq.imr_multiaddr.s_addr = sw_ipv4_address_saddr(multicast_address);

	res = setsockopt(self->m_desc, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char*) &mreq, sizeof(mreq));
	err = sw_translate_error(res == 0, sw_socket_errno());
	sw_check_okay_log(err, exit);

	res = setsockopt(self->m_desc, IPPROTO_IP, IP_MULTICAST_IF, (char*) &addr, sizeof(addr));
	err = sw_translate_error(res == 0, sw_socket_errno());
	sw_check_okay_log(err, exit);

	res = setsockopt(self->m_desc, IPPROTO_IP, IP_TTL, (char*) &ttl, sizeof(ttl));
	err = sw_translate_error(res == 0, sw_socket_errno());
	sw_check_okay_log(err, exit);

	res = setsockopt(self->m_desc, IPPROTO_IP, IP_MULTICAST_TTL, (char*) &real_ttl, sizeof(real_ttl));
	err = sw_translate_error(res == 0, sw_socket_errno());
	sw_check_okay_log(err, exit);

exit:

	return err;
}
예제 #13
0
sw_result
sw_corby_channel_recv(
						sw_corby_channel		self,
						sw_salt				*	salt,
						sw_corby_message	*	message,
						sw_uint32			*	request_id,
						sw_string			*	op,
						sw_uint32			*	op_len,
						sw_corby_buffer	*	buffer,
						sw_uint8			*	endian,
						sw_bool				block)
{
	static sw_const_string
	message_type[] =
	{
		"Request",
		"Reply",
		"CancelRequest",
		"LocateRequest",
		"LocateReply",
		"CloseConnection",
		"MessageError"
	};

	sw_size_t	buflen;
	sw_size_t	len;
	sw_result	err = SW_OKAY;

	SW_UNUSED_PARAM(request_id);

   sw_debug(SW_LOG_VERBOSE, "entering sw_corby_channel_recv()\n");

	if (self->m_state == Waiting)
	{
		self->m_message->m_header = NULL;
	}

	/*
	 * side effect the salt reference
	 */
	if (salt)
	{
		(*salt) = self->m_orb->m_salt;
	}
   
   while (SW_TRUE)
   {
      buflen 	= (self->m_read_buffer->m_eptr - self->m_read_buffer->m_bptr);
 		*buffer	= NULL;
		
		if (message)
   	{
			*message = NULL;
  		}
   
		sw_debug(SW_LOG_VERBOSE, "  %s %s, buffer(m_base = %x, m_bptr = %x, m_eptr = %x, m_end = %x, buflen = %d)\n",
                     (block) ? "block" : "!block",
                     (self->m_message->m_header) ? "message_header" : "!message_header",
                     self->m_read_buffer->m_base,
                     self->m_read_buffer->m_bptr,
                     self->m_read_buffer->m_eptr,
                     self->m_read_buffer->m_end,
                     buflen);
      
      /*
         beginning a new message
      */
      if (self->m_message->m_header == NULL)
      {
			self->m_state = Reading;

         /*
            do we need to shift stuff down and reset pointers?
         */
         if (buflen && (self->m_read_buffer->m_bptr != self->m_read_buffer->m_base))
         {
				sw_debug(SW_LOG_VERBOSE, "  shifting buffer pointers %d bytes\n", buflen);
				sw_memcpy(self->m_read_buffer->m_base, self->m_read_buffer->m_bptr, buflen);
         }

         self->m_read_buffer->m_bptr = self->m_read_buffer->m_base;
         self->m_read_buffer->m_eptr = self->m_read_buffer->m_base + buflen;
         
         /*
            do we have enough to read a message header
         */
         if (buflen >= sizeof(struct _sw_swop_message_header))
         {
            self->m_message->m_header = (sw_swop_message_header*) self->m_read_buffer->m_base;

				sw_debug(SW_LOG_VERBOSE, "  SWOP magic = %c %c %c %c\n", 
                     self->m_message->m_header->m_magic[0],
                     self->m_message->m_header->m_magic[1],
                     self->m_message->m_header->m_magic[2],
                     self->m_message->m_header->m_magic[3]);

            /*
               check magic string
            */
            sw_check
						(
						((self->m_message->m_header->m_magic[0] == 'S') &&
						 (self->m_message->m_header->m_magic[1] == 'W') &&
						 (self->m_message->m_header->m_magic[2] == 'O') &&
						 (self->m_message->m_header->m_magic[3] == 'P')),
						exit,
						err = SW_E_CORBY_BAD_MESSAGE
						);
            
            sw_debug(SW_LOG_VERBOSE, "  SWOP version = %d %d\n", 
                     self->m_message->m_header->m_major,
                     self->m_message->m_header->m_minor);

            /*
               check version number
            */
				sw_check
						(
						((self->m_message->m_header->m_major <= SW_SWOP_MAJOR) &&
						 (self->m_message->m_header->m_minor <= SW_SWOP_MINOR)),
						exit,
						err = SW_E_CORBY_BAD_VERSION
						);
						
            sw_debug(SW_LOG_VERBOSE, "  SWOP endian = %d\n", 
                     self->m_message->m_header->m_endian);

				sw_debug(SW_LOG_VERBOSE, "  SWOP message type = %s\n", message_type[self->m_message->m_header->m_msg_type]);

            /*
               fix size
            */
            if (self->m_message->m_header->m_endian != SW_ENDIAN)
            {
               self->m_message->m_header->m_msg_size = SW_SWAP32(self->m_message->m_header->m_msg_size);
            }

            sw_debug(SW_LOG_VERBOSE, "  SWOP size = %d\n", 
                     self->m_message->m_header->m_msg_size);
 
            /*
               make sure we have enough buffer space
            */
            if (self->m_message->m_header->m_msg_size > ((self->m_read_buffer->m_end - self->m_read_buffer->m_base) - sizeof(struct _sw_swop_message_header)))
            {
               sw_uint32 new_size;
               
               new_size								= self->m_message->m_header->m_msg_size + sizeof(struct _sw_swop_message_header);
					self->m_read_buffer->m_base = (sw_octets) sw_realloc(self->m_read_buffer->m_base, new_size);
					sw_check(self->m_read_buffer->m_base, exit, err = SW_E_MEM);

               self->m_read_buffer->m_bptr		= self->m_read_buffer->m_base;
               self->m_read_buffer->m_eptr		= self->m_read_buffer->m_base + buflen;
               self->m_read_buffer->m_end		= self->m_read_buffer->m_base + new_size;
               self->m_message->m_header	= (struct _sw_swop_message_header*) self->m_read_buffer->m_base;
            }
            
            self->m_read_buffer->m_bptr += sizeof(struct _sw_swop_message_header);
            buflen -= sizeof(struct _sw_swop_message_header);
         }
      }

      /*
         do we have the whole message?
      */
      if (self->m_message->m_header && (self->m_message->m_header->m_msg_size <= buflen))
      {
			/*
			 * we've read the whole message, so we're now
			 * waiting for a new message
			 */
			self->m_state = Waiting;

			/*
 				side effect endian
 			*/
 			if (endian)
      	{
         	*endian = self->m_message->m_header->m_endian;
 			}

			sw_corby_channel_did_read(self, self->m_read_buffer->m_base, self->m_message->m_header->m_msg_size + SW_SWOP_HEADER_SIZE);

         switch (self->m_message->m_header->m_msg_type)
         {
            case SW_SWOP_REQUEST:

					return sw_corby_channel_parse_request(self, message, op, op_len, buffer);

            case SW_SWOP_REPLY:
      
					return sw_corby_channel_parse_reply(self, message, buffer);

				case SW_SWOP_CANCEL_REQUEST:

					return sw_corby_channel_parse_cancel_request(self, message, buffer);

            case SW_SWOP_LOCATE_REQUEST:

					return sw_corby_channel_parse_locate_request(self, message, buffer);

            case SW_SWOP_LOCATE_REPLY:

					return sw_corby_channel_parse_locate_reply(self, message, buffer);

            case SW_SWOP_CLOSE_CONNECTION:

					return sw_corby_channel_parse_close_connection(self, message, buffer);

            default:
      
               return sw_corby_channel_message_error(self);
         }
      }
      
      /*
         if we get here, then we need to read
      */
      if (block)
      {
			err = sw_socket_recvfrom(self->m_socket, self->m_read_buffer->m_eptr, self->m_read_buffer->m_end - self->m_read_buffer->m_eptr, &len, &self->m_from, &self->m_from_port, NULL, NULL);
			sw_check_okay(err, exit);

			/*
			 * returning 0 is fair because the socket might have been set up
			 * in non-blocking mode.  so if len == 0, we just return from
			 * this function gracefully
			 */
			if (len > 0)
			{
				self->m_read_buffer->m_eptr += len;
				buflen =	(self->m_read_buffer->m_eptr -  self->m_read_buffer->m_bptr);
			}
			else
			{
				break;
			}
      }
		else
		{
			break;
		}
	}

exit:

	return err;
}
예제 #14
0
sw_result
sw_corby_channel_start_reply(
               sw_corby_channel			self,
               sw_corby_buffer		*	buffer,
               sw_uint32					request_id,
               sw_corby_reply_status	status)
{
	sw_result err;

	/*
	 * don't do this if this guy isn't expecting a reply
	 */
	sw_check(self->m_message->m_body.m_request_header.m_reply_expected, exit, err = SW_E_UNKNOWN);
	
   /*
      blop the SWOP message header
   */
	err = sw_corby_channel_message_header(self, SW_SWOP_REPLY);
	sw_check_okay(err, exit);
	
	/*
		service context list
	*/
	err = sw_corby_buffer_put_uint32(self->m_send_buffer, 0);
	sw_check_okay(err, exit);
	

	/*
		request id
	*/
	err = sw_corby_buffer_put_uint32(self->m_send_buffer, request_id);
	sw_check_okay(err, exit);

	/*
		status
	*/
   switch (status)
	{
		case SW_CORBY_NO_EXCEPTION:
			
			err = sw_corby_buffer_put_uint32(self->m_send_buffer, SW_CORBY_NO_EXCEPTION);
			sw_check_okay(err, exit);
			break;

		case SW_CORBY_SYSTEM_EXCEPTION:
			
			err = sw_corby_buffer_put_uint32(self->m_send_buffer, SW_CORBY_SYSTEM_EXCEPTION);
			sw_check_okay(err, exit);
			break;

		case SW_CORBY_USER_EXCEPTION:
			
         err = sw_corby_buffer_put_uint32(self->m_send_buffer, SW_CORBY_USER_EXCEPTION);
			sw_check_okay(err, exit);
			break;
			
		case SW_CORBY_LOCATION_FORWARD:
			
         /* unhandled */
			break;
	}

   *buffer = self->m_send_buffer;

exit:

	if (err != SW_OKAY)
	{
		*buffer = NULL;
	}
   
	return err;
}
예제 #15
0
sw_result
sw_corby_channel_start_request(
                        sw_corby_channel			self,
								sw_const_corby_profile	profile,
                        sw_corby_buffer		*	buffer,
								sw_const_string			op,
                        sw_uint32					oplen,
                        sw_bool						reply_expected)
{
   sw_uint32 request_id;
	sw_result	err;

   /*
	 * reset my pointers
	 */
   self->m_send_buffer->m_bptr	= self->m_send_buffer->m_base;
   self->m_send_buffer->m_eptr	= self->m_send_buffer->m_base;
   
   /*
      blop out the message header
   */
   err = sw_corby_channel_message_header(self, SW_SWOP_REQUEST);
	sw_check_okay(err, exit);

	/*
		service context
	*/
	err = sw_corby_buffer_put_uint32(self->m_send_buffer, 0);
	sw_check_okay(err, exit);

	/*
		request id
	*/
	request_id = sw_corby_channel_request_id();
	err = sw_corby_buffer_put_uint32(self->m_send_buffer, request_id);
	sw_check_okay(err, exit);

	/*
		reply expected
	*/
	err = sw_corby_buffer_put_uint8(self->m_send_buffer, reply_expected);
	sw_check_okay(err, exit);

	/*
		object key
	*/
	err = sw_corby_buffer_put_sized_octets(self->m_send_buffer, (sw_const_octets) profile->m_oid, profile->m_oid_len);
	sw_check_okay(err, exit);

	/*
		operation
	*/
	err = sw_corby_buffer_put_sized_octets(self->m_send_buffer, (sw_octets) op, oplen);
	sw_check_okay(err, exit);

	/*
		principal
	*/
	err = sw_corby_buffer_put_uint32(self->m_send_buffer, 0);
	sw_check_okay(err, exit);

   *buffer = self->m_send_buffer;

exit:

	if (err != SW_OKAY)
	{
		*buffer = NULL;
	}

   return err;
}
예제 #16
0
sw_result
sw_corby_channel_init_with_profile(
                        sw_corby_channel		*	self,
								struct _sw_corby_orb	*	orb,
								sw_const_corby_profile	profile,
								sw_socket_options			options,
								sw_size_t					bufsize)
{
	sw_corby_channel	channel;
	sw_socket			socket;
	sw_result			err;

	/*
	 * initialize
	 */
	socket	=	NULL;
	*self		=	NULL;
	err		=	SW_OKAY;

	/*
	 * let's try and see if we already have a connection to this guy
	 */
	for (channel = orb->m_channel_cache; channel; channel = channel->m_nextc)
	{
		if ((channel->m_to_tag == profile->m_tag) && sw_ipv4_address_equals(channel->m_to, profile->m_address) && (channel->m_to_port == profile->m_port))
		{
			sw_int8 name_buf[16];
			
			sw_debug(SW_LOG_NOTICE, "sharing connection to %s, %d\n", sw_ipv4_address_name(profile->m_address, name_buf, 16), profile->m_port);
			
			/*
			 * found it
			 */
			channel->m_cache_refs++;
			channel->m_refs++;
			*self = channel;
			goto exit;
		}
	}

	/*
	 * couldn't find it, so make a new one
	 */
	switch (profile->m_tag)
	{
		case SW_TAG_INTERNET_IOP:
      
			err = sw_tcp_socket_init(&socket);
			sw_check_okay(err, exit);

         break;
         
		case SW_TAG_UIOP:
      
			err = sw_udp_socket_init(&socket);
			sw_check_okay(err, exit);

			err = sw_socket_bind(socket, sw_ipv4_address_any(), 0);
			sw_check_okay(err, exit);
         
			break;
         
		case SW_TAG_MIOP:
      
			err = sw_multicast_socket_init(&socket);
			sw_check_okay(err, exit);
         
			err = sw_socket_bind(socket, sw_ipv4_address_any(), profile->m_port);
			sw_check_okay(err, exit);
         
			break;

		default:
			err = SW_E_INIT;
			goto exit;
	}
	
	/*
	 * now let's try to connect...for connectionless protocols it just stashes this info to be used later
	 */
	err = sw_socket_connect(socket, profile->m_address, profile->m_port);
	sw_check_okay(err, exit);

	err = sw_corby_channel_init(self, orb, socket, options, bufsize);
	sw_check_okay(err, exit);

	/*
	 * if we connected okay, then add to list of extant channels
	 */
	err = sw_ipv4_address_init_from_address(&(*self)->m_to, profile->m_address);
	sw_check_okay(err, exit);

	(*self)->m_to_tag				=	profile->m_tag;
	(*self)->m_to_port			=	profile->m_port;
	(*self)->m_send_queue_head	=	NULL;
	(*self)->m_send_queue_tail	=	NULL;
	(*self)->m_nextc				=	g_channel_cache;
	(*self)->m_prevc				=	NULL;
	
	if (orb->m_channel_cache)
	{
		orb->m_channel_cache->m_prevc	= (*self);
	}
	
	orb->m_channel_cache = (*self);
	(*self)->m_cache_refs++;

exit:

	if (err != SW_OKAY)
	{
		if (*self != NULL)
		{
			sw_corby_channel_fina(*self);
		}
		else if (socket != NULL)
		{
			sw_socket_fina(socket);
		}
	}

	return err;
}