OpenSync  0.22
opensync_serializer.c
1 #include "opensync.h"
2 #include "opensync_internals.h"
3 
4 int osync_marshal_get_size_changetype( OSyncChangeType changetype )
5 {
6  return sizeof( int );
7 }
8 
9 void osync_marshal_changetype( OSyncMessage *message, OSyncChangeType changetype )
10 {
11  osync_message_write_int( message, (int)changetype );
12 }
13 
14 void osync_demarshal_changetype( OSyncMessage *message, OSyncChangeType *changetype )
15 {
16  int change_type = 0;
17 
18  osync_message_read_int( message, &change_type );
19  *changetype =(OSyncChangeType)change_type;
20 }
21 
22 int osync_marshal_get_size_change( OSyncChange *change )
23 {
24  int size = 0;
25 
26  if ( !change )
27  return size;
28 
29  size += strlen( change->uid );
30  size += strlen( change->hash );
31  size += sizeof( int ); // change->size
32  size += change->size; // change->data
33  size += sizeof( int ); // change->has_data
34  size += strlen( change->objtype_name );
35  size += strlen( change->format_name );
36  size += strlen( change->initial_format_name );
37  size += osync_marshal_get_size_changetype( change->changetype );
38  size += sizeof( long long int ); // change->id
39  size += strlen( change->destobjtype );
40  size += strlen( change->sourceobjtype );
41  size += osync_marshal_get_size_member( change->sourcemember );
42 
43  return size;
44 }
45 
46 void osync_marshal_changedata(OSyncMessage *message, OSyncChange *change)
47 {
49  char *data;
50  int datasize;
51  int free_data = 0;
52 
53  osync_message_write_int( message, change->has_data );
54 
55  if (change->data && format && format->marshall_func) {
56  format->marshall_func(change->data, change->size, &data, &datasize, NULL);
57  /*FIXME: Handle errors on marshall_func */
58  free_data = 1;
59  } else {
60  /* If the format is a plain format, then we have to add
61  * one byte for \0 to the datasize. This extra byte will
62  * be removed by the osync_demarshal_changedata funciton.
63  */
64  data = change->data;
65  datasize = change->size;
66  datasize++;
67  }
68 
69  if (!data)
70  datasize = 0;
71 
72  osync_message_write_int(message, datasize);
73  if (datasize > 0)
74  osync_message_write_data(message, data, datasize);
75 
76  if (free_data)
77  g_free(data);
78 }
79 
80 void osync_marshal_change( OSyncMessage *message, OSyncChange *change )
81 {
82  osync_message_write_string( message, change->uid );
83  osync_message_write_string( message, change->hash );
84 
85  char *format_name = change->format ? change->format->name : change->format_name;
86  char *objtype_name = change->objtype ? change->objtype->name : change->objtype_name;
87  char *initial_format_name = change->initial_format ? change->initial_format->name : change->initial_format_name;
88  osync_message_write_string( message, objtype_name );
89  osync_message_write_string( message, format_name );
90  osync_message_write_string( message, initial_format_name );
91 
92  osync_marshal_changedata(message, change);
93 
94  osync_marshal_changetype( message, change->changetype );
95  osync_message_write_long_long_int( message, change->id );
96  osync_message_write_string( message, change->destobjtype );
97  osync_message_write_string( message, change->sourceobjtype );
98  osync_marshal_member( message, change->sourcemember );
99 }
100 
101 void osync_demarshal_changedata(OSyncMessage *message, OSyncChange *change)
102 {
103  OSyncObjFormat *format = osync_change_get_objformat(change);
104  char *data;
105  int datasize;
106 
107  osync_message_read_int( message, &( change->has_data ) );
108 
109  osync_message_read_int(message, &datasize);
110  if (datasize > 0) {
111  data = malloc(datasize);
112  osync_message_read_data( message, data, datasize );
113 
114  if (format && format->demarshall_func) {
115  char *newdata;
116  int newsize;
117  format->demarshall_func(data, datasize, &newdata, &newsize, NULL);
118  /*FIXME: Handle errors on demarshall_func */
119  free(data);
120  data = newdata;
121  datasize = newsize;
122  } else {
123  /* If the format is a plain, then we have to remove
124  * one from the datasize, since once one was added by
125  * osync_marshall_changedata() for trailing newline.
126  */
127  datasize--;
128  }
129  } else {
130  data = NULL;
131  }
132 
133  change->data = data;
134  change->size = datasize;
135 }
136 
137 void osync_demarshal_change( OSyncMessage *message, OSyncFormatEnv *conv_env, OSyncChange **change )
138 {
139  OSyncChange *new_change = osync_change_new();
140 
141  osync_change_set_conv_env(new_change, conv_env);
142 
143  osync_message_read_string( message, &( new_change->uid ) );
144  osync_message_read_string( message, &( new_change->hash ) );
145 
146  osync_message_read_string( message, &( new_change->objtype_name ) );
147  osync_message_read_string( message, &( new_change->format_name ) );
148  osync_message_read_string( message, &( new_change->initial_format_name ) );
149 
150  osync_demarshal_changedata(message, new_change);
151 
152  osync_demarshal_changetype( message, &( new_change->changetype ) );
153  osync_message_read_long_long_int( message, &( new_change->id ) );
154  osync_message_read_string( message, &( new_change->destobjtype ) );
155  osync_message_read_string( message, &( new_change->sourceobjtype ) );
156  osync_demarshal_member( message, &( new_change->sourcemember ) );
157 
158  new_change->member = 0;
159  new_change->engine_data = 0;
160  new_change->mappingid = 0;
161  new_change->changes_db = 0;
162 
163  *change = new_change;
164 }
165 
166 int osync_marshal_get_size_member( OSyncMember *member )
167 {
168  return sizeof( int );
169 }
170 
171 void osync_marshal_member( OSyncMessage *message, OSyncMember *member )
172 {
173  if ( member ) {
174  osync_message_write_int( message, member->id );
175  } else {
176  osync_message_write_int( message, -1 );
177  }
178 }
179 
180 void osync_demarshal_member( OSyncMessage *message, OSyncMember **member )
181 {
182  int id;
183 
184  osync_message_read_int( message, &id );
185 
186  if ( id == -1 )
187  *member = 0;
188  else {
189  //TODO: search in pool
190  }
191 }
192 
193 int osync_marshal_get_size_error( OSyncError **error )
194 {
195  int size = 0;
196 
197  if ( !osync_error_is_set(error) )
198  return size;
199 
200  size += sizeof( int );
201  size += strlen( (*error)->message );
202 
203  return size;
204 }
205 
206 void osync_marshal_error( OSyncMessage *message, OSyncError *error )
207 {
208  if (error) {
209  osync_message_write_int( message, 1 );
210  osync_message_write_int( message, (int)error->type );
211  osync_message_write_string( message, error->message );
212  } else {
213  osync_message_write_int( message, 0 );
214  }
215 }
216 
217 void osync_demarshal_error( OSyncMessage *message, OSyncError **error )
218 {
219  int hasError = 0;
220 
221  osync_message_read_int( message, &hasError );
222 
223  if (hasError) {
224  char *msg;
225  int error_type;
226 
227  osync_message_read_int( message, &error_type );
228  osync_message_read_string( message, &msg );
229 
230  osync_error_set( error, (OSyncErrorType)error_type, msg );
231  } else
232  osync_error_free(error);
233 }
234 
235 /*FIXME: review these get_size_*() functions
236  *
237  * - check if the data is being marhsalled as specified in the functions
238  * - check (proabably invalid) usage of strlen() without considering the
239  * string length bytes and the nul terminator
240  */
241 int osync_marshal_get_size_message( OSyncMessage *message )
242 {
243  int size = 0;
244 
245  if ( !message )
246  return size;
247 
248  size += sizeof( int ); // message->cmd
249  size += sizeof( long long int ); // message->id
250  size += sizeof( int ); // has error
251 
252  return 0;
253 }
Represent an error.
OSyncMember * sourcemember
osync_bool osync_error_is_set(OSyncError **error)
Checks if the error is set.
OSyncObjType * objtype
OSyncChange * osync_change_new(void)
Spawns a new change object.
OSyncErrorType
Defines the possible error types.
Definition: opensync_error.h:5
void osync_error_free(OSyncError **error)
Frees the error so it can be reused.
A member of a group which represent a single device.
OSyncObjFormat * osync_change_get_objformat(OSyncChange *change)
Gets the object format of a change.
OSyncErrorType type
long long int mappingid
OSyncObjFormat * format
void osync_change_set_conv_env(OSyncChange *change, OSyncFormatEnv *env)
Sets the conversion environment of a change.
A change object.
void osync_error_set(OSyncError **error, OSyncErrorType type, const char *format,...)
Sets the error.
OSyncObjFormat * initial_format
Represent a format for a object type.
OSyncChangeType
The changetypes of a change object.
Definition: opensync.h:28
The environment used for conversions.
OSyncChangeType changetype