예제 #1
0
/**
 * Attempt to iterate to the next DBusMessage argument, while checking that
 * the new argument isn't WHITEBOARD_CMD_DATA_END
 *
 * @param iter An iterator
 */
static gboolean whiteboard_cmd_iter_next_internal(WhiteBoardCmdIter* iter)
{
	const gchar* str = NULL;

	whiteboard_log_debug_fb();

	/* Jump to the next item, fail if there are no more items */
	if (dbus_message_iter_next(&iter->iter) == FALSE)
	{
		whiteboard_log_debug_fe();
		return FALSE;
	}

	/* Check that the current item is a string, fail if not */
	if (dbus_message_iter_get_arg_type(&iter->iter) != DBUS_TYPE_STRING)
	{
		whiteboard_log_debug_fe();
		return FALSE;
	}

	/* Check that the current item is not an end marker */
	dbus_message_iter_get_basic(&iter->iter, &str);
	if (str == NULL || strcmp(str, WHITEBOARD_CMD_DATA_END) == 0)
	{
		whiteboard_log_debug_fe();
		return FALSE;
	}
	
	whiteboard_log_debug_fe();

	return TRUE;
}
/**
 * Start a UPnP service. This function will block until the service is stopped.
 *
 * @param service The service to start
 * @return -1 on errors, 0 on success
 */
gint sib_service_start(SIBService* service)
{
  gint retval = 0;
  whiteboard_log_debug_fb();

  g_return_val_if_fail(service != NULL, -1);
  g_return_val_if_fail(service->main_loop != NULL, -1);

  if (g_main_loop_is_running(service->main_loop) == TRUE)
    {
      whiteboard_log_debug("sib_service_start(): main loop running\n");
      whiteboard_log_debug_fe();
      return -1;
    }
  else
    {
    
  
      /* TODO: control channel uuid define */
      service->control_channel = 
	WHITEBOARD_SIB_ACCESS(whiteboard_sib_access_new(NULL,
							(guchar *)"unique_whiteboard_sib_nota_cc_id",
						       NULL,
						       (guchar *)"SIB Access",
						       (guchar *)"Not yet done"));
      
      g_signal_connect(G_OBJECT(service->control_channel),
		       WHITEBOARD_SIB_ACCESS_SIGNAL_REFRESH,
		       (GCallback) sib_service_refresh_cb,
		       NULL);
      
      g_signal_connect(G_OBJECT(service->control_channel),
		       WHITEBOARD_SIB_ACCESS_SIGNAL_SHUTDOWN,
		       (GCallback) sib_service_shutdown_cb,
		       NULL);
      
      retval = sib_service_controller_start( g_main_loop_get_context(service->main_loop) );
      if(retval < 0)
	{
	  whiteboard_log_error("SIB Controller start failed\n");
	  retval = -1;
	  //	  exit(1);
	}
      
      whiteboard_log_debug("RUnning main loop\n");
      g_main_loop_run(service->main_loop);
    }
  
  whiteboard_log_debug_fe();
  
  return retval;
}
예제 #3
0
gboolean whiteboard_cmd_iter_init(WhiteBoardCmd* self, WhiteBoardCmdIter* iter)
{
	gint arg_type = 0;
	const gchar* str = NULL;

	whiteboard_log_debug_fb();

	g_return_val_if_fail(self != NULL, FALSE);
	g_return_val_if_fail(iter != NULL, FALSE);

	iter->data = self;
	dbus_message_iter_init(self->msg, &iter->iter);

	/* Skip all arguments before the begin marker */
	while ( (arg_type = dbus_message_iter_get_arg_type(&iter->iter))
		!= DBUS_TYPE_INVALID)
	{
		if (arg_type == DBUS_TYPE_STRING)
		{
			dbus_message_iter_get_basic(&iter->iter, &str);
			if (str != NULL &&
			    strcmp(str, WHITEBOARD_CMD_DATA_BEGIN) == 0)
			{
				dbus_message_iter_next(&iter->iter);
				return TRUE;
			}
		}

		dbus_message_iter_next(&iter->iter);
	}

	whiteboard_log_debug_fe();

	return FALSE;
}
예제 #4
0
파일: main.c 프로젝트: smart-m3/sib-nota
void register_sib_cb(SibObject* context,
		     SibObjectHandle *handle,
		     gchar *uri,
		     gpointer user_data)
{
  NotaRMHandler *rm = (NotaRMHandler *)user_data;
  gint ret = -1;
  gint sid = -1;
  whiteboard_log_debug_fb();

  sid = nota_rm_handler_register_sib(rm, uri);
  
  if(sid<0)
    {
      whiteboard_log_debug("Registering sib: %s to RM failed\n", uri);
      ret = -1;
      sib_object_send_register_sib_return(handle, ret);
    }
  else
    {
      ret = 0;

      sib_object_send_register_sib_return(handle, ret);
      
      whiteboard_log_debug("Creating listener for SID: %d\n",sid);
      kplistener = kp_listener_new(sid, nota_rm_handler_get_maxfd(rm));
    }
  whiteboard_log_debug_fe();
}
static void sib_service_device_listener(SIBDeviceStatus status, SIBServerData *ssdata, gpointer user_data)
{
  SIBService *service = NULL;
  whiteboard_log_debug_fb();

  service = (SIBService *)user_data;
  g_return_if_fail(service != NULL);
  
  switch(status)
    {
    case SIBDeviceStatusAdded:
      whiteboard_log_debug("SIBDeviceStatusAdded: %s<%s>\n", ssdata->name,ssdata->uri );
      g_return_if_fail(ssdata!= NULL);
      sib_service_add_server(service,ssdata->uri,ssdata->name, ssdata->sid, ssdata->port);
      break;
    case SIBDeviceStatusRemoved:
      whiteboard_log_debug("SIBDeviceStatusRemoved: %s<%s>\n",ssdata->name,ssdata->uri );
      sib_service_remove_server(service,ssdata->uri);
      break;
    case SIBDeviceStatusInvalid:
      whiteboard_log_debug("SIBDeviceStatusInvalid: %s<%s>\n",ssdata->name,ssdata->uri );
      sib_service_remove_server(service,ssdata->uri);
      break;
    default:
      whiteboard_log_error("Unknown SIBDeviceStatus for server: %s\n",ssdata->uri );
      break;
    }
   
  whiteboard_log_debug_fe();
}
예제 #6
0
WhiteBoardCmdRequest* whiteboard_cmd_new_request(const gchar* method,
					     const gchar* target_uuid)
{
	WhiteBoardCmd* self = NULL;
	const gchar* begin = WHITEBOARD_CMD_DATA_BEGIN;

	whiteboard_log_debug_fb();

	g_return_val_if_fail(method != NULL, NULL);
	g_return_val_if_fail(target_uuid != NULL, NULL);

	self = g_new0(WhiteBoardCmd, 1);
	g_return_val_if_fail(self != NULL, NULL);

	self->refcount = 1;
	self->msg = dbus_message_new_method_call(WHITEBOARD_DBUS_SERVICE,
						 WHITEBOARD_DBUS_OBJECT,
						 WHITEBOARD_DBUS_INTERFACE,
						 WHITEBOARD_DBUS_METHOD_CUSTOM_COMMAND);
	g_return_val_if_fail(self->msg != NULL, NULL);

	whiteboard_cmd_append_method_name(self, method);
	whiteboard_cmd_append_target_uuid(self, target_uuid);

	dbus_message_append_args(self->msg,
				 DBUS_TYPE_STRING, &begin,
				 DBUS_TYPE_INVALID);

	whiteboard_log_debug_fe();

	return (WhiteBoardCmdRequest*) self;
}
예제 #7
0
void kp_server_handle_remove_cnf( SibObject *context,
				  guchar *spaceid,
				  guchar *nodeid,
				  gint msgnum,
				  gint success,
				  gpointer user_data)
{
  KPServer *self = NULL;
  whiteboard_log_debug_fb();
  self = (KPServer *)user_data;
  
  g_mutex_lock(self->send_lock);
  whiteboard_log_debug("RemoveCnf ->\n");
  whiteboard_log_debug("\tspaceid: %s\n", spaceid);
  whiteboard_log_debug("\tnodeid: %s\n", nodeid);
  whiteboard_log_debug("\tmsgnum: %d\n", msgnum);
  whiteboard_log_debug("\tsuccess: %d\n", success);  
  if( SibAccessNota_Remove_cnf(self->cp,
			       (uint8_t *) nodeid,
			       (uint16_t) strlen( (gchar *)nodeid),
			       (uint8_t *) spaceid,
			       (uint16_t) strlen( (gchar *)spaceid),
			       (uint16_t) msgnum,
			       (sibstatus_t) success) < 0 )
    {
      whiteboard_log_warning("Remove cnf sending failed\n");
    }
  else
    {
      whiteboard_log_debug("Remove cnf sent\n");
    }
  g_mutex_unlock(self->send_lock);
  whiteboard_log_debug_fe();
}
예제 #8
0
void kp_server_handle_leave_ind( SibObject *context,
				 guchar *spaceid,
				 guchar *nodeid,
				 gint msgnum,
				 gint status,
				 gpointer user_data)
{
  KPServer *self = NULL;
  whiteboard_log_debug_fb();
  self = (KPServer *)user_data;
  
  g_mutex_lock(self->send_lock);
  
  if( SibAccessNota_Leave_ind(self->cp,
			      (uint8_t *) nodeid,
			      (uint16_t) strlen( (gchar *)nodeid),
			      (uint8_t *) spaceid,
			      (uint16_t) strlen( (gchar *)spaceid),
			      (uint16_t) msgnum,
			      status)  <  0 )
    {
      whiteboard_log_warning("Leave ind sending failed\n");
    }
  else
    {
      whiteboard_log_debug("Leave ind sent\n");
    }
  g_mutex_unlock(self->send_lock);
  whiteboard_log_debug_fe();
}
예제 #9
0
static void sib_controller_resolver_found( GaServiceResolver *context,
					   gint interface,
					   gint protocol,
					   gchar *name,
					   gchar *type,
					   gchar *domain,
					   gchar *host_name,
					   AvahiAddress *avahi_address,
					   gint port,
					   AvahiStringList *txt,
					   gint flags,
					   gpointer userdata)
{
  whiteboard_log_debug_fb();
  SIBController *self = (SIBController *)userdata;
  g_return_if_fail( self!= NULL);
  SIBServerData *ssdata = NULL;

  ssdata = sib_controller_get_service(self, (guchar *)name);
  if(ssdata)
    {
      
      ssdata->ip = g_new0(gchar, AVAHI_ADDRESS_STR_MAX);
      avahi_address_snprint(ssdata->ip, AVAHI_ADDRESS_STR_MAX*sizeof(gchar), avahi_address);
      ssdata->name = (guchar *)g_strdup(host_name);
      ssdata->port = port;
      whiteboard_log_debug("Service %s resolved: %s, %d\n", name, ssdata->ip, port);
      self->listener( SIBDeviceStatusAdded, ssdata, self->listener_data );
    }
  whiteboard_log_debug_fe();
}
/**
 * Unlock a SIBService instance after a critical operation
 *
 * @param self The SIBService instance to unlock
 */
void sib_service_unlock(SIBService* self)
{
  whiteboard_log_debug_fb();
  g_return_if_fail(self != NULL);
  g_mutex_unlock(self->mutex);
  whiteboard_log_debug_fe();
}
예제 #11
0
static void sib_controller_removed_service_cb( GaServiceBrowser *context,
					   gint interface,
					   gint protocol,
					   gchar *name,
					   gchar *type,
					   gchar *domain,
					   gint flags,
					   gpointer userdata)
{
  whiteboard_log_debug_fb();
  SIBController *self = (SIBController *)userdata;
  g_return_if_fail(self!=NULL);
  whiteboard_log_debug("Removed service: %s, type %s, domain: %s\n", name, type, domain);
  SIBServerData *ssdata = sib_controller_get_service(self, (guchar *)name);
  if( ssdata )
    {
      if( ssdata->ip ) // assume that if ip is filled, resolver has finished
	{
	  // notify listener
	  self->listener( SIBDeviceStatusRemoved, ssdata, self->listener_data );
	}
      sib_controller_remove_service(self, (guchar *)name);
    }
  whiteboard_log_debug_fe();
}
// TODO: change UDN to SIB_identifier
gint sib_service_add_server(SIBService* service , guchar *udn, guchar *name, gint sid, gint port )
{
  SIBServer *server = NULL;
  
  whiteboard_log_debug_fb();
  
  sib_service_lock(service);

  server = sib_service_find_server(service, udn);
  if (server == NULL)
    {
      server = sib_server_new(service, udn, name, sid, port);
      if (server != NULL)
	{
	  //upnpserver_subscribe(server);
	  
	  service->siblist =
	    g_list_append(service->siblist,
			  server);
	}
    }
  
  sib_service_unlock(service);
  
  whiteboard_log_debug_fe();
  return 0;
}
/**
 * Remove a server from the service by the server's UDN.
 *
 * @param service The service to remove from
 * @param udn The UDN of the server to remove
 * @return -1 on errors, 0 on success
 */
gint sib_service_remove_server(SIBService* service, guchar *udn )
{
  GList* item = NULL;
  gint retval = -1;

  whiteboard_log_debug_fb();

  g_return_val_if_fail(service != NULL, -1);

  sib_service_lock(service);
  item = g_list_find_custom(service->siblist, udn,
			    sib_server_compare_udn);

  if (item != NULL)
    {
      sib_server_unref((SIBServer*) item->data);
      
      service->siblist =
	g_list_remove_link(service->siblist, item);
      
      retval = 0;
    }
  else
    {
      whiteboard_log_debug("Device %s is not in our server list. Ignored.\n",
			   udn);
    }
  
  sib_service_unlock(service);
  
  whiteboard_log_debug_fe();
  
  return retval;
}
예제 #14
0
void nota_rm_handler_destroy(NotaRMHandler *self)
{
  h_in_t *core = Hgetinstance();
  whiteboard_log_debug_fb();

  if(self->sid)
    {
      nota_rm_handler_deregister_service(self);
    }

  if(self->dereg_cert)
    {
      g_free(self->dereg_cert);
    }
  if(self->dereg_act)
    {
      g_free(self->dereg_act);
    }

  if(self->cp)
    {
      nota_stub_context_pointer_free(self->cp);
    }
  
  if(self->fd > 0 )
    {
      Hclose(core, self->fd);
      self->fd = -1;
    }
  
  g_free(self);
  
  whiteboard_log_debug_fe();
}
예제 #15
0
gint kp_server_send_join( KPServer *self, guchar *spaceid, guchar *nodeid, gint msgnum, guchar *credentials)
{
  gint retval;
  whiteboard_log_debug_fb();
  retval = sib_object_send_join( self->sib, spaceid, nodeid, msgnum, credentials);
  whiteboard_log_debug_fe();
  return retval;
}
예제 #16
0
gint kp_server_send_update( KPServer *self, guchar *spaceid, guchar *nodeid, gint msgnum, EncodingType encoding, guchar *insert_graph, guchar *remove_graph)
{
  gint retval;
  whiteboard_log_debug_fb();
  retval = sib_object_send_update( self->sib, spaceid, nodeid, msgnum, encoding, insert_graph, remove_graph);
  whiteboard_log_debug_fe();
  return retval;
}
예제 #17
0
gint kp_server_send_subscribe( KPServer *self, guchar *spaceid, guchar *nodeid, gint msgnum, QueryType type, guchar *query)
{
  gint retval;
  whiteboard_log_debug_fb();
  retval = sib_object_send_subscribe( self->sib, spaceid, nodeid, msgnum, type, query);
  whiteboard_log_debug_fe();
  return retval;
}
예제 #18
0
gint kp_server_handle_incoming( KPServer *self)
{
  gint retval;
  whiteboard_log_debug_fb();
  retval = nota_stub_handle_incoming( self->cp );
  whiteboard_log_debug_fe();
  return retval;
}
예제 #19
0
gint kp_server_send_unsubscribe( KPServer *self, guchar *spaceid, guchar *nodeid, gint msgnum, guchar *subscription_id)
{
  gint retval;
  whiteboard_log_debug_fb();
  retval = sib_object_send_unsubscribe( self->sib, spaceid, nodeid, msgnum, subscription_id);
  whiteboard_log_debug_fe();
  return retval;
}
예제 #20
0
gint sib_controller_set_listener(SIBController *self, SIBControllerListener listener, gpointer user_data)
{
whiteboard_log_debug_fb();
  g_return_val_if_fail( self != NULL, -1);

  self->listener = listener;
  self->listener_data = user_data;
  whiteboard_log_debug_fe();
  return 0;
}
예제 #21
0
/**
 * Get the SIBService singleton.
 *
 * @return SIBService*
 */
SIBController* sib_controller_get()
{
  whiteboard_log_debug_fb();
  if (controller_singleton == NULL)
    {
      controller_singleton = sib_controller_new();
    }
  whiteboard_log_debug_fe();
  return controller_singleton;
}
예제 #22
0
static void sib_controller_all_for_now_cb( GaServiceBrowser *context,
					   gpointer userdata)
{
  whiteboard_log_debug_fb();

  

  
  whiteboard_log_debug_fe();
}
예제 #23
0
static void whiteboard_cmd_append_target_uuid(WhiteBoardCmd* self,
					    const gchar* uuid)
{
	whiteboard_log_debug_fb();

	dbus_message_append_args(self->msg,
				 DBUS_TYPE_STRING, &uuid,
				 DBUS_TYPE_INVALID);

	whiteboard_log_debug_fe();
}
/**
 * Get the SIBService singleton.
 *
 * @return SIBService*
 */
SIBService* sib_service_get()
{
  whiteboard_log_debug_fb();
  if (service_singleton == NULL)
    {
      service_singleton = sib_service_new();
      serverthread_init(service_singleton);
    }
  whiteboard_log_debug_fe();
  return service_singleton;
}
예제 #25
0
static void whiteboard_cmd_append_method_name(WhiteBoardCmd* self,
					    const gchar* method)
{
	whiteboard_log_debug_fb();

	dbus_message_append_args(self->msg,
				 DBUS_TYPE_STRING, &method,
				 DBUS_TYPE_INVALID);

	whiteboard_log_debug_fe();
}
예제 #26
0
NotaRMHandler *nota_rm_handler_new(SIBMaxFd *maxfd)
{
  
  NotaRMHandler *self = NULL;
  whiteboard_log_debug_fb();
  self = g_new0(NotaRMHandler, 1);
  self->fd = -1;
  self->maxfd = maxfd;
  whiteboard_log_debug_fe();
  return self;
}
예제 #27
0
gint create_rm_socket(NotaRMHandler *self)
{
  nota_addr_t addr = { SID_RM, 0};
  h_in_t *core = Hgetinstance();
  whiteboard_log_debug_fb();
  if(!core)
    {
      whiteboard_log_debug("Could not get H_IN core pointer.\n");
      return -1;
    }
  
  
  self->fd = Hsocket(core, AF_NOTA, SOCK_STREAM, 0);
  if(self->fd <=0)
    {
      whiteboard_log_debug("Could not get H_IN socket.\n");
      self->fd = -1;
      return -1;
    }
  
  if( Hconnect(core, self->fd, (struct sockaddr*)&addr, sizeof(addr)) < 0)
    {
      whiteboard_log_debug("Could not connect\n");
      Hclose(core, self->fd);
      self->fd = -1;
      return -1;
    }
  whiteboard_log_debug("Socket connected(%d)\n", self->fd);
  self->cp = nota_stub_context_pointer_initialize(core, self->fd);
  if(!self->cp)
    {
      whiteboard_log_debug("Could not create STUB context pointer\n");
      Hclose(core, self->fd);
      self->fd = -1;
      return -1;
    }
  
  whiteboard_log_debug("STUB context inialized\n");
  if( NoTA_System_ResourceMng_R01_01_user_new_connection(self->cp) < 0)
    {
      whiteboard_log_debug("could not add to stub\n");
      nota_stub_context_pointer_free(self->cp);
      self->cp = NULL;
      Hclose(core, self->fd);
      self->fd = -1;
      return -1;
    }
  self->cp->user_pointer = self;
  sib_maxfd_set(self->maxfd, self->fd);
  whiteboard_log_debug(" Stub connected for socket: %d\n", self->fd);
  whiteboard_log_debug_fe();
  return 0;
}
static void sib_service_shutdown_cb(WhiteBoardNode* context,
				    gpointer user_data)
{
  SIBService* service = NULL;

  whiteboard_log_debug_fb();

  service = sib_service_get();
  sib_service_stop(service);

  whiteboard_log_debug_fe();
}
예제 #29
0
/**
 * Stop a controller
 *
 * @param controller The controller to stop
 * @return -1 on errors, 0 on success
 */
gint sib_controller_stop(SIBController* controller)
{
  whiteboard_log_debug_fb();

  g_return_val_if_fail(controller != NULL, -1);

  
  
  whiteboard_log_debug_fe();

  return 0;
}
static void sib_service_refresh_cb(WhiteBoardNode* context,
				   gpointer user_data)
{
  SIBService* service = NULL;

  whiteboard_log_debug_fb();

  service = sib_service_get();
  //  g_return_if_fail(service->cp_running == TRUE);
  //cg_upnp_controlpoint_search(service->cp, "upnp:rootdevice");

  whiteboard_log_debug_fe();
}