Пример #1
0
sw_result
sw_ipv4_address_init_from_name(
				sw_ipv4_address	*	self,
				sw_const_string		addr)
{
	sw_result err = SW_OKAY;

	//
	// check to see whether this is dotted decimal or not
	//
	int part[4];
	int ret;

	ret = sscanf(addr, "%d.%d.%d.%d", &part[0], &part[1], &part[2], &part[3]);

	if (ret == 4)
	{
		self->m_addr = inet_addr(addr);
	}
	else
	{
		struct hostent * hEntry = gethostbyname(addr);
		sw_check(hEntry != NULL, exit, err = SW_E_UNKNOWN);

		self->m_addr = *(sw_uint32*) hEntry->h_addr;
	}

	sw_check(self->m_addr != INADDR_NONE, exit, err = SW_E_UNKNOWN);

exit:

	return err;
}
Пример #2
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;
}
Пример #3
0
sw_string
sw_strdup(sw_const_string str)
{
	sw_string	ret = NULL;
	sw_result	err;
	
	if (str == NULL)
	{
		return NULL;
	}
	
	ret = malloc(strlen(str) + 1);
	sw_check(ret, exit, err = SW_E_MEM);

	sw_strcpy(ret, str);

exit:

	return ret;
}
Пример #4
0
int main(){
	// Initialize Peripherals
	interface_init();
	red_led_on();
	uart_init(BAUDRATE);
	animation_manager_init();
	sys_timer_start();
	audio_init();
	sei();	// enable global interrupts

	// Load Default Animation
	animation_manager_load_animation(START_ANIMATION);

	// Enter Setup if Requested
	_delay_ms(100);
	if(deb_switch_1()){
		setup_wb_run();
	}
	else if(deb_switch_2()){
		setup_orientation_run();
	}

	// Load Default Animation
	animation_manager_load_animation(START_ANIMATION);

	// Set White Balance
	_delay_ms(300);
	display_wb_update();
	while(uart_async_run());	// setup white balance

	// Control Panel is Ready => Signal this by Turning the LED Green
	red_led_off();
	green_led_on();

	while(1){
		// Sleep Mode
		if(!switch_on_off()){	// if switched off
			go_to_sleep();
		}

		// Change animations
		sw_check();
		if(sw_check_pressed(SW_LEFT, 200, true)){
			animation_manager_dec_animation();
		}
		else if(sw_check_pressed(SW_RIGHT, 200, true)){
			animation_manager_inc_animation();
		}
		else if(sw_check_pressed(SW_RAND, 300, true)){
			animation_manager_random_animation();
		}

		// Generate Image
		animation_manager_run(0);

		// Check Audio
		audio_start();
		while(audio_run());
		audio_process();

		// Display Image
		while(uart_async_run()){
			interface_async_run();
		}

	}
}
Пример #5
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;
}
Пример #6
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;
}