utils
[Internal functions of Easydbus Library]

Collaboration diagram for utils:

---

Detailed Description

Module of internal utils.

This module contains functions used internally for some particular task.

(Documentation TO COMPLETE)

Utils Meta Information

Contact:

Daniele Rondina aka Ge@@ru <geaaru@gmail.com>

Status:

EasyDbus Core Library

License:

GPL

Contributor(s):

• Daniele Rondina aka Ge@@ru <geaaru@gmail.com>

Functions
char *	add_el_signature (enum el_type type_el, char *old_signature, int marshal_data_status)
	Add element type to signature string.
int	count_elems (struct EasyDbus_elem *el, int *error, enum signature_flags flags)
	Count elements for signature creations of element passed.
int	count_total_elems (struct EasyDbus_elem *el, int *error)
	Count signature elements for all elements list passed in input.
int	easydbus_manage_list_signature (struct easydbus_signature_elem_stack *el, char **signature, int flags)
	Convert signature element on signature string char.
int	easydbus_save_serviceName (struct EasyDbus_core *core, char *serviceName)
	Save service name on EasyDbus_core object.
enum el_type	get_easydbus_type_from_dbus_type (int type)
	Convert DBus type element value to EasyDbus type element value.
char *	prepare_complete_signature (struct EasyDbus_elem *el)
	Create signature string of element. This function is used for debug.
char *	prepare_match_string (enum event_type type, char *sender, char *interface, char *member, char *path, char *destination)
	This function create match string used on match rule dbus call.
char *	prepare_signature (struct EasyDbus_elem *el, enum signature_flags flags)
	Create signature string of element. Used for marshalled data.
int	set_signature (struct EasyDbus_elem *el, char *signature, int offset, enum signature_flags flags)
	Set signature on buffer passed in input.

---

Function Documentation

char* add_el_signature	(	enum el_type	type_el,
		char *	old_signature,
		int	marshal_data_status
	)

Add element type to signature string.

add element signature to string passed in input, if string is equal to NULL than create a new string.

For internal use only.

Returns:

NULL on error

pointer to signature string updated or new string signature update if old_signature is equal to NULL.

Parameters:

	type_el	type of elem to add on signature.
	old_signature	signature to insert on new signature before new element. (if old_signature == NULL a new signature is created). (if old_signature != NULL this string is freeing);
	marshal_data_status	this value is used for manage marshalled data: 0 --> open marshalled data; 1 --> close marshalled data.

Todo:

manage marshalled data: array, dict_entry, struct, variant.

Definition at line 790 of file utils.c.

References EASYDBUS_ELTYPE_ARRAY, EASYDBUS_ELTYPE_BOOLEAN, EASYDBUS_ELTYPE_BYTE, EASYDBUS_ELTYPE_DICT_ENTRY, EASYDBUS_ELTYPE_DOUBLE, EASYDBUS_ELTYPE_INT16, EASYDBUS_ELTYPE_INT32, EASYDBUS_ELTYPE_INT64, EASYDBUS_ELTYPE_INVALID, EASYDBUS_ELTYPE_OBJECT_PATH, EASYDBUS_ELTYPE_SIGNATURE, EASYDBUS_ELTYPE_STRING, EASYDBUS_ELTYPE_STRUCT, EASYDBUS_ELTYPE_UINT16, EASYDBUS_ELTYPE_UINT32, EASYDBUS_ELTYPE_UINT64, and EASYDBUS_ELTYPE_VARIANT.

Referenced by easydbus_manage_list_signature().

{
   char *signature = NULL;
   int offset = 0;
   int signature_length = 0;

   if (old_signature == NULL) {
      signature = (char *) malloc (2);
      if (signature == NULL)
         return NULL;
      memset (signature, 0, 2);

   }
   else {
      signature_length = strlen (old_signature) + 1;
      signature = (char *) malloc (signature_length + 1);
      if (signature == NULL)
         return NULL;
      memset (signature, 0, signature_length + 1);
      memcpy (signature, old_signature, signature_length);
      offset = signature_length - 1;
      free (old_signature);
   }

   switch (type_el) {
      case EASYDBUS_ELTYPE_STRING:
         signature[offset] = DBUS_TYPE_STRING;
         break;
      case EASYDBUS_ELTYPE_BYTE:
         signature[offset] = DBUS_TYPE_BYTE;
         break;
      case EASYDBUS_ELTYPE_BOOLEAN:
         signature[offset] = DBUS_TYPE_BOOLEAN;
         break;
      case EASYDBUS_ELTYPE_DOUBLE:
         signature[offset] = DBUS_TYPE_DOUBLE;
         break;
      case EASYDBUS_ELTYPE_INT16:
         signature[offset] = DBUS_TYPE_INT16;
         break;
      case EASYDBUS_ELTYPE_UINT16:
         signature[offset] = DBUS_TYPE_UINT16;
         break;
      case EASYDBUS_ELTYPE_INT32:
         signature[offset] = DBUS_TYPE_INT32;
         break;
      case EASYDBUS_ELTYPE_UINT32:
         signature[offset] = DBUS_TYPE_UINT32;
         break;
      case EASYDBUS_ELTYPE_INT64:
         signature[offset] = DBUS_TYPE_INT64;
         break;
      case EASYDBUS_ELTYPE_UINT64:
         signature[offset] = DBUS_TYPE_UINT64;
         break;
      case EASYDBUS_ELTYPE_OBJECT_PATH:
         signature[offset] = DBUS_TYPE_OBJECT_PATH;
         break;
      case EASYDBUS_ELTYPE_VARIANT:
         signature[offset] = DBUS_TYPE_VARIANT;
         break;
      case EASYDBUS_ELTYPE_DICT_ENTRY:
         if (marshal_data_status)
            signature[offset] = DBUS_DICT_ENTRY_END_CHAR;
         else
            signature[offset] = DBUS_DICT_ENTRY_BEGIN_CHAR;
         break;
      case EASYDBUS_ELTYPE_ARRAY:
         signature[offset] = DBUS_TYPE_ARRAY;
         break;
      case EASYDBUS_ELTYPE_SIGNATURE:
         signature[offset] = DBUS_TYPE_SIGNATURE;
         break;
      case EASYDBUS_ELTYPE_STRUCT:
         if (marshal_data_status)
            signature[offset] = DBUS_STRUCT_END_CHAR;
         else
            signature[offset] = DBUS_STRUCT_BEGIN_CHAR;
         break;
      case EASYDBUS_ELTYPE_INVALID:
         goto error;
         break;
   }

   return signature;

 error:
   if (signature != NULL)
      free (signature);
   return NULL;
}

int count_elems	(	struct EasyDbus_elem *	el,
		int *	error,
		enum signature_flags	flags
	)

Count elements for signature creations of element passed.

count number of elements connected from element passed in input save number to int passed in input

Note:

For any type founded is returned 1. While for array, dict_entry, struct, is called recursively count_elems function. For signature isn't important when elements on array there are, but how array and elements are insert on hierarchical struct.
For example:
aaii --> array of ( array of two int32 )
signature:
I level:
sig_lev1[0] = DBUS_TYPE_ARRAY;
sig_lev1[1] = DBUS_TYPE_ARRAY;
sig_lev1[2] = DBUS_TYPE_INT32;
sig_lev1[3] = '\0';
II level:
sig_lev2[0] = DBUS_TYPE_ARRAY;
sig_lev2[1] = DBUS_TYPE_INT32;
sig_lev2[2] = '\0';
So if on II level array there are 100 number int32 signature is always for type of field.

Todo:

• manage dict_entry;
• manage struct;
• manage variant;

Parameters:

	el	EasyDbus_elem object pointer
	error	where is saved error state. error == 1 --> error error == 0 --> no error
	flags	used for indicated policy for count element operations.

Returns:

number of elements for signature.

For internal use only.

Definition at line 217 of file utils.c.

References count_elems(), EASYDBUS_ELTYPE_ARRAY, EASYDBUS_ELTYPE_BOOLEAN, EASYDBUS_ELTYPE_BYTE, EASYDBUS_ELTYPE_DICT_ENTRY, EASYDBUS_ELTYPE_DOUBLE, EASYDBUS_ELTYPE_INT16, EASYDBUS_ELTYPE_INT32, EASYDBUS_ELTYPE_INT64, EASYDBUS_ELTYPE_INVALID, EASYDBUS_ELTYPE_OBJECT_PATH, EASYDBUS_ELTYPE_SIGNATURE, EASYDBUS_ELTYPE_STRING, EASYDBUS_ELTYPE_STRUCT, EASYDBUS_ELTYPE_UINT16, EASYDBUS_ELTYPE_UINT32, EASYDBUS_ELTYPE_UINT64, EASYDBUS_ELTYPE_VARIANT, EASYDBUS_SIGNATURE_VARIANT, EasyDbusDebug, EasyDbus_container::elem_type, EasyDbus_container::nel, EasyDbus_elem::next, EasyDbus_elem::p_container, EasyDbus_container::p_data, EasyDbus_elem::payload, and EasyDbus_elem::type.

Referenced by count_elems(), count_total_elems(), prepare_complete_signature(), prepare_signature(), and set_signature().

{
   struct EasyDbus_container *container;
   struct EasyDbus_elem *internal_el;
   int elems_founded = 0;
   unsigned int i;

   switch (el->type) {
      case EASYDBUS_ELTYPE_STRING:
      case EASYDBUS_ELTYPE_BYTE:
      case EASYDBUS_ELTYPE_BOOLEAN:
      case EASYDBUS_ELTYPE_DOUBLE:
      case EASYDBUS_ELTYPE_INT16:
      case EASYDBUS_ELTYPE_UINT16:
      case EASYDBUS_ELTYPE_INT32:
      case EASYDBUS_ELTYPE_UINT32:
      case EASYDBUS_ELTYPE_INT64:
      case EASYDBUS_ELTYPE_UINT64:
      case EASYDBUS_ELTYPE_OBJECT_PATH:
      case EASYDBUS_ELTYPE_SIGNATURE:
         //EasyDbusDebug ("founded elem\n");
         elems_founded++;
         break;
      case EASYDBUS_ELTYPE_VARIANT:
         /* variant is composed by v signature
          * and a normal type:
          * signature[..] := DBUS_TYPE_VARIANT
          * signature[..+1] := DBUS_TYPE_* 
          */
         if (flags & EASYDBUS_SIGNATURE_VARIANT)
            elems_founded += 1;
         elems_founded += 1;
         EasyDbusDebug ("founded elem %d\n", elems_founded);
         break;
      case EASYDBUS_ELTYPE_DICT_ENTRY:
         EasyDbusDebug ("founded elem\n");
         /* dict_entry is composed by:
          * DBUS_DICT_ENTRY_BEGIN_CHAR
          * + 2 elems
          * DBUS_DICT_ENTRY_END_CHAR */
         container = el->payload.p_container;
         elems_founded += 2;
         internal_el = (struct EasyDbus_elem *) container->p_data;
         for (i = 0; i < 2; i++) {
            elems_founded += count_elems (internal_el, error, flags);
            if (*error == 1)
               return 0;
            internal_el = internal_el->next;
         }
         break;
      case EASYDBUS_ELTYPE_STRUCT:
         // for STRUCT type it is needed
         // two field for 
         // DBUS_STRUCT_BEGIN_CHAR
         // DBUS_STRUCT_END_CHAR
         container = el->payload.p_container;
         elems_founded += 2;
         internal_el = (struct EasyDbus_elem *) container->p_data;
         for (i = 0; i < container->nel; i++) {
            EasyDbusDebug ("manage elem %d of struct\n", i + 1);
            elems_founded += count_elems (internal_el, error, flags);
            if (*error == 1)
               return 0;
            internal_el = internal_el->next;
            EasyDbusDebug ("founded elem %d\n", elems_founded);
         }
         EasyDbusDebug ("founded elem %d\n", elems_founded);
         break;
      case EASYDBUS_ELTYPE_INVALID:
         *error = 1;
         break;
      case EASYDBUS_ELTYPE_ARRAY:
         EasyDbusDebug ("founded elem\n");
         container = el->payload.p_container;
         elems_founded = 1;
         switch (container->elem_type) {
            case EASYDBUS_ELTYPE_ARRAY:
               internal_el = (struct EasyDbus_elem *)
                  container->p_data;
               for (i = 0; i < container->nel; i++) {
                  elems_founded +=
                     count_elems (internal_el, error, flags);
                  if (*error == 1)
                     return 0;
                  internal_el++;
               }
               EasyDbusDebug ("founded elem\n");
               break;
            case EASYDBUS_ELTYPE_STRING:
            case EASYDBUS_ELTYPE_BYTE:
            case EASYDBUS_ELTYPE_BOOLEAN:
            case EASYDBUS_ELTYPE_DOUBLE:
            case EASYDBUS_ELTYPE_INT16:
            case EASYDBUS_ELTYPE_UINT16:
            case EASYDBUS_ELTYPE_INT32:
            case EASYDBUS_ELTYPE_UINT32:
            case EASYDBUS_ELTYPE_INT64:
            case EASYDBUS_ELTYPE_UINT64:
            case EASYDBUS_ELTYPE_OBJECT_PATH:
            case EASYDBUS_ELTYPE_SIGNATURE:
               EasyDbusDebug ("founded elem\n");
               elems_founded++;
               break;
            case EASYDBUS_ELTYPE_VARIANT:
               elems_founded += 2;
               EasyDbusDebug ("founded elem %d\n", elems_founded);
               break;
            case EASYDBUS_ELTYPE_DICT_ENTRY:
               container = el->payload.p_container;
               elems_founded += 2;
               internal_el =
                  (struct EasyDbus_elem *) container->p_data;
               internal_el = internal_el->payload.p_container->p_data;
               for (i = 0; i < 2; i++) {
                  EasyDbusDebug ("founded elem %d\n", elems_founded);
                  elems_founded +=
                     count_elems (internal_el, error, flags);
                  if (*error == 1)
                     return 0;
                  internal_el = internal_el->next;
               }
               EasyDbusDebug ("founded elem %d\n", elems_founded);
               break;
            case EASYDBUS_ELTYPE_STRUCT:
               container = el->payload.p_container;
               internal_el =
                  (struct EasyDbus_elem *) container->p_data;
               elems_founded +=
                  count_elems (internal_el, error, flags);
               if (*error == 1)
                  return 0;
               EasyDbusDebug ("founded elem %d\n", elems_founded);
               break;
            case EASYDBUS_ELTYPE_INVALID:
               *error = 1;
               break;
         }
         break;
   }
   return elems_founded;
}

Here is the call graph for this function:

int count_total_elems	(	struct EasyDbus_elem *	el,
		int *	error
	)

Count signature elements for all elements list passed in input.

For internal use only.

Parameters:

	el	EasyDbus_elem object used as start pointer for count
	error	where is saved error state. error == 1 --> error error == 0 --> no error

Returns:

number of elements for signature.

Definition at line 371 of file utils.c.

References count_elems(), EASYDBUS_SIGNATURE_NORMAL, and EasyDbus_elem::next.

Referenced by prepare_complete_signature().

{
   int elems_founded = 0;

   *error = 0;
   while (el != NULL) {
      elems_founded += count_elems (el, error,
                                    EASYDBUS_SIGNATURE_NORMAL);
      el = el->next;
   }
   return elems_founded;
}

Here is the call graph for this function:

int easydbus_manage_list_signature	(	struct easydbus_signature_elem_stack *	el,
		char **	signature,
		int	flags
	)

Convert signature element on signature string char.

Parameters:

	el	signature_elem_stack object to convert.
	signature	pointer to signature buffer.
	flags	used for indicated policy for signature creation.

Returns:

-1 error

0 ok

For internal use only.

Definition at line 894 of file utils.c.

References add_el_signature(), EASYDBUS_ELTYPE_ARRAY, EASYDBUS_ELTYPE_DICT_ENTRY, EASYDBUS_ELTYPE_INVALID, EASYDBUS_ELTYPE_STRUCT, EASYDBUS_ELTYPE_VARIANT, easydbus_free_elem_from_stack(), easydbus_manage_list_signature(), EasyDbusDebug, easydbus_signature_elem_stack::next, easydbus_signature_elem_stack::type, and EasyDbus_elem::type.

Referenced by easydbus_container_add_signature_to_empty_container(), easydbus_create_arg_signature(), and easydbus_manage_list_signature().

{
   enum el_type type = EASYDBUS_ELTYPE_INVALID;
   struct easydbus_signature_elem_stack *tmp = NULL;

   if (el == NULL || signature == NULL)
      return -1;

   switch (el->type) {
      case EASYDBUS_ELTYPE_VARIANT:
         if (el->next == NULL)
            return -1;
         *signature = add_el_signature (el->type, *signature, 0);
         /* variant element type is ignored */
         //container->signature = add_el_signature 
         // (el->next->type, container->signature, 0);
         EasyDbusDebug ("Ignore variant element type");
         easydbus_free_elem_from_stack (el->next);
         break;
      case EASYDBUS_ELTYPE_DICT_ENTRY:
         /* dict entry signature are managed in this way:
          * - EASYDBUS_ELTYPE_DICT_ENTRY +
          *   EASYDBUS_ELTYPE_1+ EASYDBUS_ELTYPE_2
          *   if elem of dict entry is a variant element, then
          *   also another field is inserted.
          */
         // open dict_entry
         *signature = add_el_signature (el->type, *signature, 0);
         /* check first elem (the key) */
         if (el->next == NULL)
            return -1;
         type = el->next->type;

         if (type == EASYDBUS_ELTYPE_INVALID ||
             type == EASYDBUS_ELTYPE_ARRAY ||
             type == EASYDBUS_ELTYPE_STRUCT ||
             type == EASYDBUS_ELTYPE_DICT_ENTRY)
            return -1;

         if (easydbus_manage_list_signature
             (el->next, signature, flags))
            return -1;

         /* check second elem */
         if (el->next->next == NULL)
            return -1;
         type = el->next->next->type;

         if (type == EASYDBUS_ELTYPE_INVALID ||
             type == EASYDBUS_ELTYPE_ARRAY ||
             type == EASYDBUS_ELTYPE_STRUCT ||
             type == EASYDBUS_ELTYPE_DICT_ENTRY)
            return -1;

         if (easydbus_manage_list_signature
             (el->next->next, signature, flags))
            return -1;

         /* remove dict entry elements */
         easydbus_free_elem_from_stack (el->next);
         easydbus_free_elem_from_stack (el->next);

         // close dict_entry 
         *signature = add_el_signature (el->type, *signature, 1);
         break;
      case EASYDBUS_ELTYPE_STRUCT:
         *signature = add_el_signature (el->type, *signature, 0);
         while (el->next != NULL &&
                el->next->type != EASYDBUS_ELTYPE_STRUCT &&
                el->next->type != EASYDBUS_ELTYPE_INVALID) {
            if (easydbus_manage_list_signature
                (el->next, signature, flags))
               return -1;
            tmp = el->next;
            el->next = el->next->next;
            easydbus_free_elem_from_stack (tmp);
         }
         if (el->next == NULL)
            return -1;
         if (el->next->type == EASYDBUS_ELTYPE_STRUCT) {
            *signature = add_el_signature
               (el->next->type, *signature, 1);
         }
         else
            return -1;
         easydbus_free_elem_from_stack (el->next);
         break;
      case EASYDBUS_ELTYPE_ARRAY:
         *signature = add_el_signature (el->type, *signature, 0);
         if (el->next == NULL)
            return -1;
         if (easydbus_manage_list_signature (el->next,
                                             signature, flags))
            return -1;
         // remove array element 
         easydbus_free_elem_from_stack (el->next);
         break;
      case EASYDBUS_ELTYPE_INVALID:
         return -1;
         break;
      default:
         *signature = add_el_signature (el->type, *signature, 0);
         break;
   }

   return 0;
}

Here is the call graph for this function:

int easydbus_save_serviceName	(	struct EasyDbus_core *	core,
		char *	serviceName
	)			[inline]

Save service name on EasyDbus_core object.

save service name to struct EasyDbus_core passed in input

Parameters:

	core	EasyDbus_core object pointer
	serviceName	service name to save.

Returns:

0 ok

-1 error

For internal use only.

Definition at line 57 of file utils.c.

References EASYDBUS_MEMCOPY, and EasyDbus_core::service_name.

Referenced by easydbus_conn_get_system_service_address(), easydbus_get_address_onsession(), easydbus_get_address_onsystem(), and easydbus_get_address_serverSession().

{
   int serviceNameL = 0;

   serviceNameL = strlen (serviceName) + 1;
   core->service_name = (char *) malloc (serviceNameL);

   if (core->service_name == NULL)
      return -1;

   EASYDBUS_MEMCOPY (core->service_name, serviceName, 
                     serviceNameL);

   return 0;
}

enum el_type get_easydbus_type_from_dbus_type

(

int

type

)

Convert DBus type element value to EasyDbus type element value.

For internal use only.

Parameters:

type

DBus type to convert

Returns:

easydbus_type_value

Definition at line 1010 of file utils.c.

References EASYDBUS_ELTYPE_ARRAY, EASYDBUS_ELTYPE_BOOLEAN, EASYDBUS_ELTYPE_BYTE, EASYDBUS_ELTYPE_DICT_ENTRY, EASYDBUS_ELTYPE_DOUBLE, EASYDBUS_ELTYPE_INT16, EASYDBUS_ELTYPE_INT32, EASYDBUS_ELTYPE_INT64, EASYDBUS_ELTYPE_INVALID, EASYDBUS_ELTYPE_OBJECT_PATH, EASYDBUS_ELTYPE_SIGNATURE, EASYDBUS_ELTYPE_STRING, EASYDBUS_ELTYPE_STRUCT, EASYDBUS_ELTYPE_UINT16, EASYDBUS_ELTYPE_UINT32, EASYDBUS_ELTYPE_UINT64, and EASYDBUS_ELTYPE_VARIANT.

Referenced by easydbus_get_marshal_data_from_array().

{
   switch (type) {
      case DBUS_TYPE_ARRAY:
         return EASYDBUS_ELTYPE_ARRAY;
         break;
      case DBUS_TYPE_STRUCT:
         return EASYDBUS_ELTYPE_STRUCT;
         break;
      case DBUS_TYPE_VARIANT:
         return EASYDBUS_ELTYPE_VARIANT;
         break;
      case DBUS_TYPE_DICT_ENTRY:
         return EASYDBUS_ELTYPE_DICT_ENTRY;
         break;
      case DBUS_TYPE_SIGNATURE:
         return EASYDBUS_ELTYPE_SIGNATURE;
         break;
      case DBUS_TYPE_OBJECT_PATH:
         return EASYDBUS_ELTYPE_OBJECT_PATH;
         break;
      case DBUS_TYPE_DOUBLE:
         return EASYDBUS_ELTYPE_DOUBLE;
         break;
      case DBUS_TYPE_BOOLEAN:
         return EASYDBUS_ELTYPE_BOOLEAN;
         break;
      case DBUS_TYPE_BYTE:
         return EASYDBUS_ELTYPE_BYTE;
         break;
      case DBUS_TYPE_UINT64:
         return EASYDBUS_ELTYPE_UINT64;
         break;
      case DBUS_TYPE_INT64:
         return EASYDBUS_ELTYPE_INT64;
         break;
      case DBUS_TYPE_UINT16:
         return EASYDBUS_ELTYPE_UINT16;
         break;
      case DBUS_TYPE_INT16:
         return EASYDBUS_ELTYPE_INT16;
         break;
      case DBUS_TYPE_INT32:
         return EASYDBUS_ELTYPE_INT32;
         break;
      case DBUS_TYPE_UINT32:
         return EASYDBUS_ELTYPE_UINT32;
         break;
      case DBUS_TYPE_STRING:
         return EASYDBUS_ELTYPE_STRING;
         break;
      default:
         return EASYDBUS_ELTYPE_INVALID;
         break;
   }
}

char* prepare_complete_signature

(

struct EasyDbus_elem *

el

)

Create signature string of element. This function is used for debug.

For internal use only.

Parameters:

el

EasyDbus_elem object used as start pointer for signature string creation

Returns:

NULL on error

signature string to free.

Definition at line 395 of file utils.c.

References count_elems(), count_total_elems(), EASYDBUS_SIGNATURE_NORMAL, EasyDbusDebug, EasyDbus_elem::next, and set_signature().

{
   int number_of_elems = 0;
   int num_of_elems_from_one_node = 0;
   char *signature = NULL;
   int error = 0;

   if (el != NULL)
      number_of_elems = count_total_elems (el, &error);
   if (error)
      return NULL;
   EasyDbusDebug ("COUNT = %d\n", number_of_elems);
   signature = (char *) malloc (sizeof (char[number_of_elems + 1]));
   if (signature == NULL)
      return NULL;
   memset (signature, 0, number_of_elems + 1);

   while (el != NULL) {
      if (set_signature (el, signature,
                         num_of_elems_from_one_node,
                         EASYDBUS_SIGNATURE_NORMAL)) {
         free (signature);
         return NULL;
      }
      num_of_elems_from_one_node += count_elems (el, &error, 0);
      EasyDbusDebug ("Signature prepared for %d elems: %s",
          num_of_elems_from_one_node, signature);
      el = el->next;
   }
   EasyDbusDebug ("Signature complete prepared for %d elems: %s",
                  number_of_elems, signature);
   return signature;
}

Here is the call graph for this function:

char* prepare_match_string	(	enum event_type	type,
		char *	sender,
		char *	interface,
		char *	member,
		char *	path,
		char *	destination
	)			[inline]

This function create match string used on match rule dbus call.

This function create match rule string and return her pointer. Note: this pointer must be free before lost this pointer.

For internal use only.

Returns:

pointer to match rule. Needed free of string.

NULL on error.

Definition at line 82 of file utils.c.

References EASYDBUS_ET_FAILURE, EASYDBUS_ET_METHOD, EASYDBUS_ET_REPLY, EASYDBUS_ET_SIGNAL, EASYDBUS_MATCHRULE_FOR_COMMA, EASYDBUS_MATCHRULE_FOR_DESTINATION, EASYDBUS_MATCHRULE_FOR_INTERFACE, EASYDBUS_MATCHRULE_FOR_MEMBER, EASYDBUS_MATCHRULE_FOR_PATH, EASYDBUS_MATCHRULE_FOR_SENDER, EASYDBUS_MATCHRULE_FOR_SINGLE_QUOTE, and EASYDBUS_MATCHRULE_FOR_TYPE.

Referenced by easydbus_conn_add_match_rule(), and easydbus_conn_remove_match_rule().

{

   unsigned char s, t, i, m, p, d;

   s = t = i = m = p = d = 0;
   int buffer_lenght;
   char *type_string = NULL;
   char *buffer = NULL;

   switch (type) {
      case EASYDBUS_ET_METHOD:
         type_string = (char *) dbus_message_type_to_string
            (DBUS_MESSAGE_TYPE_METHOD_CALL);
         t = 1;
         break;
      case EASYDBUS_ET_SIGNAL:
         type_string = (char *) dbus_message_type_to_string
            (DBUS_MESSAGE_TYPE_SIGNAL);
         t = 1;
         break;
      case EASYDBUS_ET_REPLY:
         type_string = (char *) dbus_message_type_to_string
            (DBUS_MESSAGE_TYPE_METHOD_RETURN);
         t = 1;
         break;
      case EASYDBUS_ET_FAILURE:
         type_string = (char *) dbus_message_type_to_string
            (DBUS_MESSAGE_TYPE_ERROR);
         t = 1;
         break;
      default:
         return NULL;
         break;
   }

   if (sender != NULL)
      s = 1;
   if (interface != NULL)
      i = 1;
   if (member != NULL)
      m = 1;
   if (path != NULL)
      p = 1;
   if (destination != NULL)
      d = 1;

   buffer_lenght =
      (t ? strlen (type_string) + 1 + 7 : 0) +
      (s ? strlen (sender) + 1 + 9 : 0) +
      (i ? strlen (interface) + 1 + 12 : 0) +
      (m ? strlen (member) + 1 + 8 : 0) +
      (p ? strlen (path) + 1 + 7 : 0) +
      (d ? strlen (destination) + 1 + 14 : 0) + 10;

   buffer = (char *) malloc (buffer_lenght);
   if (buffer == NULL)
      return NULL;
   memset (buffer, 0, buffer_lenght);

   snprintf (buffer, buffer_lenght,
             "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
             (t ? EASYDBUS_MATCHRULE_FOR_TYPE : ""),
             (t ? type_string : ""),
             (t ? EASYDBUS_MATCHRULE_FOR_SINGLE_QUOTE : ""),
             (t ? ((s || i || m || p || d) ?
                   EASYDBUS_MATCHRULE_FOR_COMMA : "") : ""),
             (s ? EASYDBUS_MATCHRULE_FOR_SENDER : ""),
             (s ? sender : ""),
             (s ? EASYDBUS_MATCHRULE_FOR_SINGLE_QUOTE : ""),
             (s ? ((i || m || p || d) ?
                   EASYDBUS_MATCHRULE_FOR_COMMA : "") : ""),
             (i ? EASYDBUS_MATCHRULE_FOR_INTERFACE : ""),
             (i ? interface : ""),
             (i ? EASYDBUS_MATCHRULE_FOR_SINGLE_QUOTE : ""),
             (i ? ((m || p || d) ?
                   EASYDBUS_MATCHRULE_FOR_COMMA : "") : ""),
             (m ? EASYDBUS_MATCHRULE_FOR_MEMBER : ""),
             (m ? member : ""),
             (m ? EASYDBUS_MATCHRULE_FOR_SINGLE_QUOTE : ""),
             (m ? ((p || d) ?
                   EASYDBUS_MATCHRULE_FOR_COMMA : "") : ""),
             (p ? EASYDBUS_MATCHRULE_FOR_PATH : ""),
             (p ? path : ""),
             (p ? EASYDBUS_MATCHRULE_FOR_SINGLE_QUOTE : ""),
             (p ? (d ? EASYDBUS_MATCHRULE_FOR_COMMA : "") : ""),
             (d ? EASYDBUS_MATCHRULE_FOR_DESTINATION : ""),
             (d ? destination : ""),
             (d ? EASYDBUS_MATCHRULE_FOR_SINGLE_QUOTE : ""));

   return buffer;
}

char* prepare_signature	(	struct EasyDbus_elem *	el,
		enum signature_flags	flags
	)

Create signature string of element. Used for marshalled data.

function for create signature for container objects

For internal use only.

Parameters:

	el	EasyDbus_elem object used as start pointer for signature string creation
	flags	used for indicated policy for signature creation

Returns:

NULL on error

signature string to free.

Definition at line 441 of file utils.c.

References count_elems(), EasyDbusDebug, and set_signature().

Referenced by add_array_to_msg(), add_variant_to_container_on_msg(), add_variant_to_msg(), and easydbus_add_array_on_container_tomsg().

{
   int number_of_elems = 0;
   char *signature = NULL;
   int error = 0;

   if (el != NULL)
      number_of_elems = count_elems (el, &error, flags);
   if (error)
      return NULL;
   EasyDbusDebug ("COUNT = %d\n", number_of_elems);
   signature = (char *) malloc (sizeof (char[number_of_elems + 1]));
   if (signature == NULL)
      return NULL;
   memset (signature, 0, number_of_elems + 1);

   if (set_signature (el, signature, 0, flags)) {
      free (signature);
      return NULL;
   }
   EasyDbusDebug ("Signature prepared for %d elems: %s",
                  number_of_elems, signature);
   return signature;
}

Here is the call graph for this function:

int set_signature	(	struct EasyDbus_elem *	el,
		char *	signature,
		int	offset,
		enum signature_flags	flags
	)

Set signature on buffer passed in input.

set signature chars to string passed in input

Parameters:

	signature	signature where is insert signature chars
	offset	offset used on signature char array for saved elems signature char.
	el	EasyDbus_elem object used as start pointer for signature string creation
	flags	used for indicated policy for signature creation.

Returns:

0 ok

-1 error

Todo:

• manage dict_entry;
• manage struct;
• manage variant;

For internal use only.

Definition at line 486 of file utils.c.

References count_elems(), EASYDBUS_ELTYPE_ARRAY, EASYDBUS_ELTYPE_BOOLEAN, EASYDBUS_ELTYPE_BYTE, EASYDBUS_ELTYPE_DICT_ENTRY, EASYDBUS_ELTYPE_DOUBLE, EASYDBUS_ELTYPE_INT16, EASYDBUS_ELTYPE_INT32, EASYDBUS_ELTYPE_INT64, EASYDBUS_ELTYPE_INVALID, EASYDBUS_ELTYPE_OBJECT_PATH, EASYDBUS_ELTYPE_SIGNATURE, EASYDBUS_ELTYPE_STRING, EASYDBUS_ELTYPE_STRUCT, EASYDBUS_ELTYPE_UINT16, EASYDBUS_ELTYPE_UINT32, EASYDBUS_ELTYPE_UINT64, EASYDBUS_ELTYPE_VARIANT, EASYDBUS_SIGNATURE_NORMAL, EASYDBUS_SIGNATURE_VARIANT, EasyDbusDebug, EasyDbus_container::elem_type, EasyDbus_container::nel, EasyDbus_elem::next, EasyDbus_elem::p_container, EasyDbus_container::p_data, EasyDbus_elem::payload, set_signature(), and EasyDbus_elem::type.

Referenced by prepare_complete_signature(), prepare_signature(), and set_signature().

{
   struct EasyDbus_container *container = NULL;
   struct EasyDbus_elem *dict_entry = NULL;
   struct EasyDbus_container *dict_container = NULL;
   struct EasyDbus_elem *internal_el = NULL;
   unsigned int i;
   int error = 0;

   switch (el->type) {
      case EASYDBUS_ELTYPE_STRING:
         signature[offset] = DBUS_TYPE_STRING;
         break;
      case EASYDBUS_ELTYPE_BYTE:
         signature[offset] = DBUS_TYPE_BYTE;
         break;
      case EASYDBUS_ELTYPE_BOOLEAN:
         signature[offset] = DBUS_TYPE_BOOLEAN;
         break;
      case EASYDBUS_ELTYPE_DOUBLE:
         signature[offset] = DBUS_TYPE_DOUBLE;
         break;
      case EASYDBUS_ELTYPE_INT16:
         signature[offset] = DBUS_TYPE_INT16;
         break;
      case EASYDBUS_ELTYPE_UINT16:
         signature[offset] = DBUS_TYPE_UINT16;
         break;
      case EASYDBUS_ELTYPE_INT32:
         signature[offset] = DBUS_TYPE_INT32;
         break;
      case EASYDBUS_ELTYPE_UINT32:
         signature[offset] = DBUS_TYPE_UINT32;
         break;
      case EASYDBUS_ELTYPE_INT64:
         signature[offset] = DBUS_TYPE_INT64;
         break;
      case EASYDBUS_ELTYPE_UINT64:
         signature[offset] = DBUS_TYPE_UINT64;
         break;
      case EASYDBUS_ELTYPE_OBJECT_PATH:
         signature[offset] = DBUS_TYPE_OBJECT_PATH;
         break;
      case EASYDBUS_ELTYPE_SIGNATURE:
         signature[offset] = DBUS_TYPE_SIGNATURE;
         break;
      case EASYDBUS_ELTYPE_VARIANT:
         signature[offset] = DBUS_TYPE_VARIANT;
         if (flags & EASYDBUS_SIGNATURE_VARIANT) {
            container = el->payload.p_container;
            switch (container->elem_type) {
               case EASYDBUS_ELTYPE_STRING:
                  signature[offset + 1] = DBUS_TYPE_STRING;
                  break;
               case EASYDBUS_ELTYPE_BYTE:
                  signature[offset + 1] = DBUS_TYPE_BYTE;
                  break;
               case EASYDBUS_ELTYPE_DOUBLE:
                  signature[offset + 1] = DBUS_TYPE_DOUBLE;
                  break;
               case EASYDBUS_ELTYPE_BOOLEAN:
                  signature[offset + 1] = DBUS_TYPE_BOOLEAN;
                  break;
               case EASYDBUS_ELTYPE_INT16:
                  signature[offset + 1] = DBUS_TYPE_INT16;
                  break;
               case EASYDBUS_ELTYPE_UINT16:
                  signature[offset + 1] = DBUS_TYPE_UINT16;
                  break;
               case EASYDBUS_ELTYPE_INT32:
                  signature[offset + 1] = DBUS_TYPE_INT32;
                  break;
               case EASYDBUS_ELTYPE_UINT32:
                  signature[offset + 1] = DBUS_TYPE_UINT32;
                  break;
               case EASYDBUS_ELTYPE_INT64:
                  signature[offset + 1] = DBUS_TYPE_INT64;
                  break;
               case EASYDBUS_ELTYPE_UINT64:
                  signature[offset + 1] = DBUS_TYPE_UINT64;
                  break;
               case EASYDBUS_ELTYPE_OBJECT_PATH:
                  signature[offset + 1] = DBUS_TYPE_OBJECT_PATH;
                  break;
               case EASYDBUS_ELTYPE_SIGNATURE:
                  signature[offset + 1] = DBUS_TYPE_SIGNATURE;
                  break;
               default:
                  /* manage error  */
                  break;
            }
         }                      // end of if (flags)
         break;
      case EASYDBUS_ELTYPE_STRUCT:
         signature[offset] = DBUS_STRUCT_BEGIN_CHAR;
         container = el->payload.p_container;
         internal_el = (struct EasyDbus_elem *)
            container->p_data;
         i = 1;
         while (internal_el != NULL) {
            if (set_signature (internal_el, signature,
                               offset + i, flags))
               return -1;
            // found offset for signature of next element.
            i += count_elems (internal_el, &error,
                              EASYDBUS_SIGNATURE_NORMAL);
            if (error == 1)
               EasyDbusDebug ("Error on calculate"
                              " offset for signature");
            internal_el = internal_el->next;
            EasyDbusDebug ("offset = %d, i = %d", offset, i);
         }
         signature[offset + i] = DBUS_STRUCT_END_CHAR;
         break;
      case EASYDBUS_ELTYPE_DICT_ENTRY:
         signature[offset] = DBUS_DICT_ENTRY_BEGIN_CHAR;
         container = el->payload.p_container;
         internal_el = (struct EasyDbus_elem *)
            container->p_data;
         if (set_signature
             (internal_el, signature, offset + 1, flags))
            return -1;
         if (set_signature (internal_el->next,
                            signature, offset + 2, flags))
            return -1;
         /* signature for dict_entry with variant must indicate
          * only variant char not element of variant char. So,
          * for example for a dict entry of string and variant
          * char, is needed:
          * - a signature {sv} for dict_entry;
          * - a signature {vs} for variant.
          */
         if (internal_el->next->type == EASYDBUS_ELTYPE_VARIANT
             && (flags & EASYDBUS_SIGNATURE_VARIANT))
            signature[offset + 4] = DBUS_DICT_ENTRY_END_CHAR;
         else
            signature[offset + 3] = DBUS_DICT_ENTRY_END_CHAR;
         break;
      case EASYDBUS_ELTYPE_INVALID:
         break;
      case EASYDBUS_ELTYPE_ARRAY:
         signature[offset] = DBUS_TYPE_ARRAY;
         container = el->payload.p_container;
         switch (container->elem_type) {
            case EASYDBUS_ELTYPE_ARRAY:
               internal_el =
                  (struct EasyDbus_elem *) container->p_data;
               for (i = 0; i < container->nel; i++) {
                  if (set_signature (internal_el,
                                     signature, offset + 1, flags))
                     return -1;
                  internal_el++;
               }
               break;
               /* isn't possible use also set_signature() in recursive
                * mode because data for string, byte, etc. on array
                * are saved without struct EasyDbus_elem container 
                * for limit used memory */
            case EASYDBUS_ELTYPE_STRING:
               signature[offset + 1] = DBUS_TYPE_STRING;
               break;
            case EASYDBUS_ELTYPE_BYTE:
               signature[offset + 1] = DBUS_TYPE_BYTE;
               break;
            case EASYDBUS_ELTYPE_BOOLEAN:
               signature[offset + 1] = DBUS_TYPE_BOOLEAN;
               break;
            case EASYDBUS_ELTYPE_DOUBLE:
               signature[offset + 1] = DBUS_TYPE_DOUBLE;
               break;
            case EASYDBUS_ELTYPE_INT16:
               signature[offset + 1] = DBUS_TYPE_INT16;
               break;
            case EASYDBUS_ELTYPE_UINT16:
               signature[offset + 1] = DBUS_TYPE_UINT16;
               break;
            case EASYDBUS_ELTYPE_INT32:
               signature[offset + 1] = DBUS_TYPE_INT32;
               break;
            case EASYDBUS_ELTYPE_UINT32:
               signature[offset + 1] = DBUS_TYPE_UINT32;
               break;
            case EASYDBUS_ELTYPE_INT64:
               signature[offset + 1] = DBUS_TYPE_INT64;
               break;
            case EASYDBUS_ELTYPE_UINT64:
               signature[offset + 1] = DBUS_TYPE_UINT64;
               break;
            case EASYDBUS_ELTYPE_OBJECT_PATH:
               signature[offset + 1] = DBUS_TYPE_OBJECT_PATH;
               break;
            case EASYDBUS_ELTYPE_SIGNATURE:
               signature[offset + 1] = DBUS_TYPE_SIGNATURE;
               break;
            case EASYDBUS_ELTYPE_VARIANT:
               signature[offset + 1] = DBUS_TYPE_VARIANT;
               if (flags & EASYDBUS_SIGNATURE_VARIANT) {
                  container = el->payload.p_container;
                  switch (container->elem_type) {
                     case EASYDBUS_ELTYPE_STRING:
                        signature[offset + 2] = DBUS_TYPE_STRING;
                        break;
                     case EASYDBUS_ELTYPE_DOUBLE:
                        signature[offset + 2] = DBUS_TYPE_DOUBLE;
                        break;
                     case EASYDBUS_ELTYPE_BYTE:
                        signature[offset + 2] = DBUS_TYPE_BYTE;
                        break;
                     case EASYDBUS_ELTYPE_BOOLEAN:
                        signature[offset + 2] = DBUS_TYPE_BOOLEAN;
                        break;
                     case EASYDBUS_ELTYPE_INT16:
                        signature[offset + 2] = DBUS_TYPE_INT16;
                        break;
                     case EASYDBUS_ELTYPE_UINT16:
                        signature[offset + 2] = DBUS_TYPE_UINT16;
                        break;
                     case EASYDBUS_ELTYPE_INT32:
                        signature[offset + 2] = DBUS_TYPE_INT32;
                        break;
                     case EASYDBUS_ELTYPE_UINT32:
                        signature[offset + 2] = DBUS_TYPE_UINT32;
                        break;
                     case EASYDBUS_ELTYPE_INT64:
                        signature[offset + 2] = DBUS_TYPE_INT64;
                        break;
                     case EASYDBUS_ELTYPE_UINT64:
                        signature[offset + 2] = DBUS_TYPE_UINT64;
                        break;
                     case EASYDBUS_ELTYPE_OBJECT_PATH:
                        signature[offset + 2] = DBUS_TYPE_OBJECT_PATH;
                        break;
                     case EASYDBUS_ELTYPE_SIGNATURE:
                        signature[offset + 2] = DBUS_TYPE_SIGNATURE;
                     default:
                        /* manage error  */
                        break;
                  }
               }                //end of if (flags)
               break;
            case EASYDBUS_ELTYPE_DICT_ENTRY:
               signature[offset + 1] = DBUS_DICT_ENTRY_BEGIN_CHAR;
               /* point to dict_entry element container */
               container = el->payload.p_container;
               dict_entry = container->p_data;
               /* recover dict_entry container */
               dict_container = dict_entry->payload.p_container;
               /* get first element of dict_entry container */
               internal_el = (struct EasyDbus_elem *)
                  dict_container->p_data;
               if (set_signature (internal_el,
                                  signature, offset + 2, flags))
                  return -1;
               if (set_signature (internal_el->next,
                                  signature, offset + 3, flags))
                  return -1;
               if ((internal_el->next->type ==
                    EASYDBUS_ELTYPE_VARIANT) &&
                   (flags & EASYDBUS_SIGNATURE_VARIANT))
                  signature[offset + 5] = DBUS_DICT_ENTRY_END_CHAR;
               else
                  signature[offset + 4] = DBUS_DICT_ENTRY_END_CHAR;
               break;
            case EASYDBUS_ELTYPE_STRUCT:
               container = el->payload.p_container;
               internal_el = (struct EasyDbus_elem *)
                  container->p_data;
               if (set_signature (internal_el, signature,
                                  offset + 1, flags))
                  return -1;
               break;
            case EASYDBUS_ELTYPE_INVALID:
               return -1;
               break;
         }                      // end of switch
         break;
   }
   return 0;
}

Here is the call graph for this function:

---